| 
					
				 | 
			
			
				@@ -1130,7 +1130,6 @@ function RuntimeBrik(brikz, st) { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 				return inContext(worker, setup); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 			} catch(error) { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 				handleError(error); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-			} finally { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 				st.thisContext = null; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 			} 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 		} 
			 | 
		
	
	
		
			
				| 
					
				 | 
			
			
				@@ -20248,24 +20247,6 @@ referencedClasses: [] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 }), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 smalltalk.NodeVisitor); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				  
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-smalltalk.addMethod( 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-smalltalk.method({ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-selector: "visitClassReferenceNode:", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-category: 'visiting', 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-fn: function (aNode){ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-var self=this; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-return smalltalk.withContext(function($ctx1) {  
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-var $1; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-$1=self._visitVariableNode_(aNode); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-return $1; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-}, function($ctx1) {$ctx1.fill(self,"visitClassReferenceNode:",{aNode:aNode},smalltalk.NodeVisitor)})}, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-args: ["aNode"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-source: "visitClassReferenceNode: aNode\x0a\x09^ self visitVariableNode: aNode", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-messageSends: ["visitVariableNode:"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-referencedClasses: [] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-}), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-smalltalk.NodeVisitor); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 smalltalk.addMethod( 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 smalltalk.method({ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 selector: "visitDynamicArrayNode:", 
			 | 
		
	
	
		
			
				| 
					
				 | 
			
			
				@@ -22645,28 +22626,6 @@ referencedClasses: [] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 smalltalk.VariableNode); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				  
			 | 
		
	
		
			
				 | 
				 | 
			
			
				  
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-smalltalk.addClass('ClassReferenceNode', smalltalk.VariableNode, [], 'Compiler-AST'); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-smalltalk.ClassReferenceNode.comment="I represent an class reference node."; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-smalltalk.addMethod( 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-smalltalk.method({ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-selector: "accept:", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-category: 'visiting', 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-fn: function (aVisitor){ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-var self=this; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-return smalltalk.withContext(function($ctx1) {  
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-var $1; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-$1=_st(aVisitor)._visitClassReferenceNode_(self); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-return $1; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-}, function($ctx1) {$ctx1.fill(self,"accept:",{aVisitor:aVisitor},smalltalk.ClassReferenceNode)})}, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-args: ["aVisitor"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-source: "accept: aVisitor\x0a\x09^ aVisitor visitClassReferenceNode: self", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-messageSends: ["visitClassReferenceNode:"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-referencedClasses: [] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-}), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-smalltalk.ClassReferenceNode); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 smalltalk.addMethod( 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 smalltalk.method({ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 selector: "isNode", 
			 | 
		
	
	
		
			
				| 
					
				 | 
			
			
				@@ -27880,7 +27839,7 @@ smalltalk.InliningCodeGenerator); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				  
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 }); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				  
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-define("amber_core/Compiler-Semantic", ["amber_vm/smalltalk", "amber_vm/nil", "amber_vm/_st", "amber_core/Kernel-Objects", "amber_core/Compiler-Core"], function(smalltalk,nil,_st){ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+define("amber_core/Compiler-Semantic", ["amber_vm/smalltalk", "amber_vm/nil", "amber_vm/_st", "amber_core/Kernel-Objects", "amber_core/Compiler-Core", "amber_core/Kernel-Collections"], function(smalltalk,nil,_st){ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 smalltalk.addPackage('Compiler-Semantic'); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 smalltalk.packages["Compiler-Semantic"].transport = {"type":"amd","amdNamespace":"amber_core"}; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				  
			 | 
		
	
	
		
			
				| 
					
				 | 
			
			
				@@ -29530,28 +29489,6 @@ referencedClasses: [] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 }), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 smalltalk.SemanticAnalyzer); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				  
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-smalltalk.addMethod( 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-smalltalk.method({ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-selector: "visitClassReferenceNode:", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-category: 'visiting', 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-fn: function (aNode){ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-var self=this; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-function $ClassRefVar(){return smalltalk.ClassRefVar||(typeof ClassRefVar=="undefined"?nil:ClassRefVar)} 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-return smalltalk.withContext(function($ctx1) {  
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-var $1,$2; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-_st(self._classReferences())._add_(_st(aNode)._value()); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-$1=_st($ClassRefVar())._new(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-_st($1)._name_(_st(aNode)._value()); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-$2=_st($1)._yourself(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-_st(aNode)._binding_($2); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-return self}, function($ctx1) {$ctx1.fill(self,"visitClassReferenceNode:",{aNode:aNode},smalltalk.SemanticAnalyzer)})}, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-args: ["aNode"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-source: "visitClassReferenceNode: aNode\x0a\x09self classReferences add: aNode value.\x0a\x09aNode binding: (ClassRefVar new name: aNode value; yourself)", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-messageSends: ["add:", "classReferences", "value", "binding:", "name:", "new", "yourself"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-referencedClasses: ["ClassRefVar"] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-}), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-smalltalk.SemanticAnalyzer); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 smalltalk.addMethod( 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 smalltalk.method({ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 selector: "visitMethodNode:", 
			 | 
		
	
	
		
			
				| 
					
				 | 
			
			
				@@ -29678,26 +29615,39 @@ selector: "visitVariableNode:", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 category: 'visiting', 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 fn: function (aNode){ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 var self=this; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+var binding; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+function $ClassRefVar(){return smalltalk.ClassRefVar||(typeof ClassRefVar=="undefined"?nil:ClassRefVar)} 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 function $UnknownVar(){return smalltalk.UnknownVar||(typeof UnknownVar=="undefined"?nil:UnknownVar)} 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return smalltalk.withContext(function($ctx1) {  
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-var $1,$3,$4,$5,$2; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-$1=aNode; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-$3=_st(self["@currentScope"])._lookupVariable_(aNode); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-if(($receiver = $3) == nil || $receiver == null){ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+var $1,$2,$3,$4,$5,$6; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+binding=_st(self["@currentScope"])._lookupVariable_(aNode); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+$1=binding; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+if(($receiver = $1) == nil || $receiver == null){ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+$2=_st(_st(aNode)._value())._beginsWithCapital(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+if(smalltalk.assert($2)){ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+$3=_st($ClassRefVar())._new(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+_st($3)._name_(_st(aNode)._value()); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+$4=_st($3)._yourself(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+binding=$4; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+binding; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+_st(self._classReferences())._add_(_st(aNode)._value()); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+} else { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 self._errorUnknownVariable_(aNode); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-$4=_st($UnknownVar())._new(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-_st($4)._name_(_st(aNode)._value()); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-$5=_st($4)._yourself(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-$2=$5; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+$5=_st($UnknownVar())._new(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+_st($5)._name_(_st(aNode)._value()); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+$6=_st($5)._yourself(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+binding=$6; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+binding; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+}; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 } else { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-$2=$3; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+$1; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 }; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-_st($1)._binding_($2); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-return self}, function($ctx1) {$ctx1.fill(self,"visitVariableNode:",{aNode:aNode},smalltalk.SemanticAnalyzer)})}, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+_st(aNode)._binding_(binding); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+return self}, function($ctx1) {$ctx1.fill(self,"visitVariableNode:",{aNode:aNode,binding:binding},smalltalk.SemanticAnalyzer)})}, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 args: ["aNode"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-source: "visitVariableNode: aNode\x0a\x09\x22Bind a ScopeVar to aNode by doing a lookup in the current scope.\x0a\x09If no ScopeVar is found, bind a UnknowVar and throw an error\x22\x0a\x0a\x09aNode binding: ((currentScope lookupVariable: aNode) ifNil: [\x0a\x09\x09self errorUnknownVariable: aNode.\x0a\x09\x09UnknownVar new name: aNode value; yourself ])", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-messageSends: ["binding:", "ifNil:", "lookupVariable:", "errorUnknownVariable:", "name:", "new", "value", "yourself"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-referencedClasses: ["UnknownVar"] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+source: "visitVariableNode: aNode\x0a\x09\x22Bind a ScopeVar to aNode by doing a lookup in the current scope.\x0a\x09If no ScopeVar is found, bind a UnknowVar and throw an error.\x22\x0a\x0a\x09| binding |\x0a\x09binding := currentScope lookupVariable: aNode.\x0a\x09\x0a\x09binding ifNil: [\x0a\x09\x09aNode value beginsWithCapital\x0a\x09\x09\x09ifTrue: [ \x22Capital letter variables might be globals.\x22\x0a\x09\x09\x09\x09binding := ClassRefVar new name: aNode value; yourself.\x0a\x09\x09\x09\x09self classReferences add: aNode value]\x0a\x09\x09\x09ifFalse: [\x0a\x09\x09\x09\x09self errorUnknownVariable: aNode.\x0a\x09\x09\x09\x09binding := UnknownVar new name: aNode value; yourself ] ].\x0a\x09\x09\x0a\x09aNode binding: binding.", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+messageSends: ["lookupVariable:", "ifNil:", "ifTrue:ifFalse:", "beginsWithCapital", "value", "name:", "new", "yourself", "add:", "classReferences", "errorUnknownVariable:", "binding:"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+referencedClasses: ["ClassRefVar", "UnknownVar"] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 }), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 smalltalk.SemanticAnalyzer); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				  
			 | 
		
	
	
		
			
				| 
					
				 | 
			
			
				@@ -29723,6 +29673,24 @@ referencedClasses: [] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 }), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 smalltalk.SemanticAnalyzer.klass); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				  
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+smalltalk.addMethod( 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+smalltalk.method({ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+selector: "beginsWithCapital", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+category: '*Compiler-Semantic', 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+fn: function (){ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+var self=this; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+return smalltalk.withContext(function($ctx1) {  
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+var $1; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+$1=_st(_st(self._first())._asUppercase()).__eq_eq(self._first()); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+return $1; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+}, function($ctx1) {$ctx1.fill(self,"beginsWithCapital",{},smalltalk.String)})}, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+args: [], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+source: "beginsWithCapital\x0a\x09^ self first asUppercase == self first", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+messageSends: ["==", "asUppercase", "first"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+referencedClasses: [] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+}), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+smalltalk.String); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 }); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				  
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 define("amber_core/Compiler-Interpreter", ["amber_vm/smalltalk", "amber_vm/nil", "amber_vm/_st", "amber_core/Kernel-Methods", "amber_core/Kernel-Objects", "amber_core/Compiler-Core", "amber_core/Kernel-Exceptions", "amber_core/Compiler-AST"], function(smalltalk,nil,_st){ 
			 | 
		
	
	
		
			
				| 
					
				 | 
			
			
				@@ -30264,6 +30232,34 @@ referencedClasses: [] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 }), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 smalltalk.AIContext); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				  
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+smalltalk.addMethod( 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+smalltalk.method({ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+selector: "localAt:ifAbsent:", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+category: 'accessing', 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+fn: function (aString,aBlock){ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+var self=this; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+return smalltalk.withContext(function($ctx1) {  
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+var $2,$1; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+$1=_st(self._locals())._at_ifAbsent_(aString,(function(){ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+return smalltalk.withContext(function($ctx2) { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+$2=self._outerContext(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+if(($receiver = $2) == nil || $receiver == null){ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+return _st(aBlock)._value(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+} else { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+var context; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+context=$receiver; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+return _st(context)._localAt_ifAbsent_(aString,aBlock); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+}; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})})); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+return $1; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+}, function($ctx1) {$ctx1.fill(self,"localAt:ifAbsent:",{aString:aString,aBlock:aBlock},smalltalk.AIContext)})}, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+args: ["aString", "aBlock"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+source: "localAt: aString ifAbsent: aBlock\x0a\x09\x22Lookup the local value up to the method context\x22\x0a\x0a\x09^ self locals at: aString ifAbsent: [ \x0a\x09\x09self outerContext \x0a\x09\x09\x09ifNotNil: [ :context | context localAt: aString ifAbsent: aBlock ]\x0a\x09\x09\x09ifNil: [aBlock value] ]", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+messageSends: ["at:ifAbsent:", "locals", "ifNotNil:ifNil:", "outerContext", "localAt:ifAbsent:", "value"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+referencedClasses: [] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+}), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+smalltalk.AIContext); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 smalltalk.addMethod( 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 smalltalk.method({ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 selector: "localAt:put:", 
			 | 
		
	
	
		
			
				| 
					
				 | 
			
			
				@@ -31494,27 +31490,6 @@ referencedClasses: ["AIBlockClosure"] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 }), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 smalltalk.ASTInterpreter); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				  
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-smalltalk.addMethod( 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-smalltalk.method({ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-selector: "visitClassReferenceNode:", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-category: 'visiting', 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-fn: function (aNode){ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-var self=this; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-function $Smalltalk(){return smalltalk.Smalltalk||(typeof Smalltalk=="undefined"?nil:Smalltalk)} 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-function $PlatformInterface(){return smalltalk.PlatformInterface||(typeof PlatformInterface=="undefined"?nil:PlatformInterface)} 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-return smalltalk.withContext(function($ctx1) {  
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-self._push_(_st(_st($Smalltalk())._current())._at_ifAbsent_(_st(aNode)._value(),(function(){ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-return smalltalk.withContext(function($ctx2) { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-return _st(_st($PlatformInterface())._globals())._at_(_st(aNode)._value()); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}))); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-return self}, function($ctx1) {$ctx1.fill(self,"visitClassReferenceNode:",{aNode:aNode},smalltalk.ASTInterpreter)})}, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-args: ["aNode"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-source: "visitClassReferenceNode: aNode\x0a\x09self push: (Smalltalk current \x0a\x09\x09at: aNode value \x0a\x09\x09ifAbsent: [ PlatformInterface globals at: aNode value ])", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-messageSends: ["push:", "at:ifAbsent:", "current", "value", "at:", "globals"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-referencedClasses: ["Smalltalk", "PlatformInterface"] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-}), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-smalltalk.ASTInterpreter); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 smalltalk.addMethod( 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 smalltalk.method({ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 selector: "visitDynamicArrayNode:", 
			 | 
		
	
	
		
			
				| 
					
				 | 
			
			
				@@ -31672,8 +31647,9 @@ category: 'visiting', 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 fn: function (aNode){ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 var self=this; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 function $PlatformInterface(){return smalltalk.PlatformInterface||(typeof PlatformInterface=="undefined"?nil:PlatformInterface)} 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+function $Smalltalk(){return smalltalk.Smalltalk||(typeof Smalltalk=="undefined"?nil:Smalltalk)} 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return smalltalk.withContext(function($ctx1) {  
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-var $1,$2,$3,$5,$4; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+var $1,$2,$3,$5,$6,$4; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 $1=_st(_st(aNode)._binding())._isUnknownVar(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 if(smalltalk.assert($1)){ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 $2=self._push_(_st(_st($PlatformInterface())._globals())._at_ifAbsent_(_st(aNode)._value(),(function(){ 
			 | 
		
	
	
		
			
				| 
					
				 | 
			
			
				@@ -31687,14 +31663,23 @@ $5=_st(_st(aNode)._binding())._isInstanceVar(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 if(smalltalk.assert($5)){ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 $4=_st(_st(self._context())._receiver())._instVarAt_(_st(aNode)._value()); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 } else { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-$4=_st(self._context())._localAt_(_st(aNode)._value()); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+$4=_st(self._context())._localAt_ifAbsent_(_st(aNode)._value(),(function(){ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+return smalltalk.withContext(function($ctx2) { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+$6=_st(_st(aNode)._value())._beginsWithCapital(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+if(smalltalk.assert($6)){ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+return _st(_st($Smalltalk())._current())._at_ifAbsent_(_st(aNode)._value(),(function(){ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+return smalltalk.withContext(function($ctx3) { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+return _st(_st($PlatformInterface())._globals())._at_(_st(aNode)._value()); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+}, function($ctx3) {$ctx3.fillBlock({},$ctx2,7)})})); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+}; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,5)})})); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 }; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 _st($3)._push_($4); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return self}, function($ctx1) {$ctx1.fill(self,"visitVariableNode:",{aNode:aNode},smalltalk.ASTInterpreter)})}, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 args: ["aNode"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-source: "visitVariableNode: aNode\x0a\x09aNode binding isUnknownVar ifTrue: [\x0a\x09\x09^ self push: (PlatformInterface globals at: aNode value ifAbsent: [ self error: 'Unknown variable' ]) ].\x0a\x09\x09\x0a\x09self push: (aNode binding isInstanceVar\x0a\x09\x09ifTrue: [ self context receiver instVarAt: aNode value ]\x0a\x09\x09ifFalse: [ self context localAt: aNode value ])", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-messageSends: ["ifTrue:", "isUnknownVar", "binding", "push:", "at:ifAbsent:", "globals", "value", "error:", "ifTrue:ifFalse:", "isInstanceVar", "instVarAt:", "receiver", "context", "localAt:"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-referencedClasses: ["PlatformInterface"] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+source: "visitVariableNode: aNode\x0a\x09aNode binding isUnknownVar ifTrue: [\x0a\x09\x09^ self push: (PlatformInterface globals at: aNode value ifAbsent: [ self error: 'Unknown variable' ]) ].\x0a\x09\x09\x0a\x09self push: (aNode binding isInstanceVar\x0a\x09\x09ifTrue: [ self context receiver instVarAt: aNode value ]\x0a\x09\x09ifFalse: [ self context \x0a\x09\x09\x09localAt: aNode value\x0a\x09\x09\x09ifAbsent: [\x0a\x09\x09\x09\x09aNode value beginsWithCapital\x0a\x09\x09\x09\x09\x09ifTrue: [\x0a\x09\x09\x09\x09\x09\x09Smalltalk current \x0a\x09\x09\x09\x09\x09\x09\x09at: aNode value \x0a\x09\x09\x09\x09\x09\x09\x09ifAbsent: [ PlatformInterface globals at: aNode value ]]]])", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+messageSends: ["ifTrue:", "isUnknownVar", "binding", "push:", "at:ifAbsent:", "globals", "value", "error:", "ifTrue:ifFalse:", "isInstanceVar", "instVarAt:", "receiver", "context", "localAt:ifAbsent:", "beginsWithCapital", "current", "at:"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+referencedClasses: ["PlatformInterface", "Smalltalk"] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 }), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 smalltalk.ASTInterpreter); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				  
			 | 
		
	
	
		
			
				| 
					
				 | 
			
			
				@@ -32109,7 +32094,6 @@ smalltalk.parser = (function(){ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				         "comments": parse_comments, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				         "ws": parse_ws, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				         "identifier": parse_identifier, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        "varIdentifier": parse_varIdentifier, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				         "keyword": parse_keyword, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				         "selector": parse_selector, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				         "className": parse_className, 
			 | 
		
	
	
		
			
				| 
					
				 | 
			
			
				@@ -32130,8 +32114,6 @@ smalltalk.parser = (function(){ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				         "runtimeLiteral": parse_runtimeLiteral, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				         "literal": parse_literal, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				         "variable": parse_variable, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        "classReference": parse_classReference, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        "reference": parse_reference, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				         "keywordPair": parse_keywordPair, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				         "binarySelector": parse_binarySelector, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				         "keywordPattern": parse_keywordPattern, 
			 | 
		
	
	
		
			
				| 
					
				 | 
			
			
				@@ -32532,75 +32514,6 @@ smalltalk.parser = (function(){ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				         return result0; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				       } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				        
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-      function parse_varIdentifier() { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        var cacheKey = "varIdentifier@" + pos.offset; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        var cachedResult = cache[cacheKey]; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        if (cachedResult) { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-          pos = clone(cachedResult.nextPos); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-          return cachedResult.result; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-         
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        var result0, result1, result2; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        var pos0, pos1; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-         
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        pos0 = clone(pos); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        pos1 = clone(pos); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        if (/^[a-z]/.test(input.charAt(pos.offset))) { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-          result0 = input.charAt(pos.offset); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-          advance(pos, 1); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        } else { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-          result0 = null; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-          if (reportFailures === 0) { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            matchFailed("[a-z]"); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-          } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        if (result0 !== null) { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-          result1 = []; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-          if (/^[a-zA-Z0-9]/.test(input.charAt(pos.offset))) { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            result2 = input.charAt(pos.offset); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            advance(pos, 1); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-          } else { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            result2 = null; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            if (reportFailures === 0) { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-              matchFailed("[a-zA-Z0-9]"); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-          } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-          while (result2 !== null) { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            result1.push(result2); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            if (/^[a-zA-Z0-9]/.test(input.charAt(pos.offset))) { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-              result2 = input.charAt(pos.offset); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-              advance(pos, 1); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            } else { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-              result2 = null; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-              if (reportFailures === 0) { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                matchFailed("[a-zA-Z0-9]"); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-              } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-          } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-          if (result1 !== null) { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            result0 = [result0, result1]; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-          } else { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            result0 = null; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-            pos = clone(pos1); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-          } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        } else { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-          result0 = null; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-          pos = clone(pos1); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        if (result0 !== null) { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-          result0 = (function(offset, line, column, first, others) {return first + others.join("");})(pos0.offset, pos0.line, pos0.column, result0[0], result0[1]); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        if (result0 === null) { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-          pos = clone(pos0); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-         
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        cache[cacheKey] = { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-          nextPos: clone(pos), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-          result:  result0 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        }; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        return result0; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-      } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-       
			 | 
		
	
		
			
				 | 
				 | 
			
			
				       function parse_keyword() { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				         var cacheKey = "keyword@" + pos.offset; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				         var cachedResult = cache[cacheKey]; 
			 | 
		
	
	
		
			
				| 
					
				 | 
			
			
				@@ -33882,7 +33795,7 @@ smalltalk.parser = (function(){ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				         var pos0; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				          
			 | 
		
	
		
			
				 | 
				 | 
			
			
				         pos0 = clone(pos); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        result0 = parse_varIdentifier(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+        result0 = parse_identifier(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				         if (result0 !== null) { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				           result0 = (function(offset, line, column, identifier) { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				                              return smalltalk.VariableNode._new() 
			 | 
		
	
	
		
			
				| 
					
				 | 
			
			
				@@ -33901,59 +33814,6 @@ smalltalk.parser = (function(){ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				         return result0; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				       } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				        
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-      function parse_classReference() { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        var cacheKey = "classReference@" + pos.offset; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        var cachedResult = cache[cacheKey]; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        if (cachedResult) { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-          pos = clone(cachedResult.nextPos); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-          return cachedResult.result; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-         
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        var result0; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        var pos0; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-         
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        pos0 = clone(pos); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        result0 = parse_className(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        if (result0 !== null) { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-          result0 = (function(offset, line, column, className) { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                             return smalltalk.ClassReferenceNode._new() 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                                    ._position_((line).__at(column)) 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                                    ._value_(className); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-                         })(pos0.offset, pos0.line, pos0.column, result0); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        if (result0 === null) { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-          pos = clone(pos0); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-         
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        cache[cacheKey] = { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-          nextPos: clone(pos), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-          result:  result0 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        }; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        return result0; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-      } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-       
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-      function parse_reference() { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        var cacheKey = "reference@" + pos.offset; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        var cachedResult = cache[cacheKey]; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        if (cachedResult) { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-          pos = clone(cachedResult.nextPos); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-          return cachedResult.result; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-         
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        var result0; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-         
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        result0 = parse_variable(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        if (result0 === null) { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-          result0 = parse_classReference(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-         
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        cache[cacheKey] = { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-          nextPos: clone(pos), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-          result:  result0 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        }; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-        return result0; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-      } 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-       
			 | 
		
	
		
			
				 | 
				 | 
			
			
				       function parse_keywordPair() { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				         var cacheKey = "keywordPair@" + pos.offset; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				         var cachedResult = cache[cacheKey]; 
			 | 
		
	
	
		
			
				| 
					
				 | 
			
			
				@@ -35277,7 +35137,7 @@ smalltalk.parser = (function(){ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				          
			 | 
		
	
		
			
				 | 
				 | 
			
			
				         result0 = parse_literal(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				         if (result0 === null) { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-          result0 = parse_reference(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+          result0 = parse_variable(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				           if (result0 === null) { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				             result0 = parse_subexpression(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				           } 
			 |