|  | @@ -6,8 +6,10 @@ smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "analyze:forClass:",
 | 
	
		
			
				|  |  |  fn: function (aNode,aClass){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  | -return smalltalk.withContext(function($ctx1) { 
var $1;
 | 
	
		
			
				|  |  | -_st(_st((smalltalk.SemanticAnalyzer || SemanticAnalyzer))._on_(aClass))._visit_(aNode);
 | 
	
		
			
				|  |  | +function $SemanticAnalyzer(){return smalltalk.SemanticAnalyzer||(typeof SemanticAnalyzer=="undefined"?nil:SemanticAnalyzer)}
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  | +var $1;
 | 
	
		
			
				|  |  | +_st(_st($SemanticAnalyzer())._on_(aClass))._visit_(aNode);
 | 
	
		
			
				|  |  |  $1=aNode;
 | 
	
		
			
				|  |  |  return $1;
 | 
	
		
			
				|  |  |  }, function($ctx1) {$ctx1.fill(self,"analyze:forClass:",{aNode:aNode,aClass:aClass},smalltalk.AbstractASTInterpreterTest)})},
 | 
	
	
		
			
				|  | @@ -20,8 +22,10 @@ smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "interpret:",
 | 
	
		
			
				|  |  |  fn: function (aString){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  | -return smalltalk.withContext(function($ctx1) { 
var $1;
 | 
	
		
			
				|  |  | -$1=_st(self)._interpret_withArguments_(aString,_st((smalltalk.Dictionary || Dictionary))._new());
 | 
	
		
			
				|  |  | +function $Dictionary(){return smalltalk.Dictionary||(typeof Dictionary=="undefined"?nil:Dictionary)}
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  | +var $1;
 | 
	
		
			
				|  |  | +$1=_st(self)._interpret_withArguments_(aString,_st($Dictionary())._new());
 | 
	
		
			
				|  |  |  return $1;
 | 
	
		
			
				|  |  |  }, function($ctx1) {$ctx1.fill(self,"interpret:",{aString:aString},smalltalk.AbstractASTInterpreterTest)})},
 | 
	
		
			
				|  |  |  messageSends: ["interpret:withArguments:", "new"]}),
 | 
	
	
		
			
				|  | @@ -34,11 +38,14 @@ selector: "interpret:receiver:withArguments:",
 | 
	
		
			
				|  |  |  fn: function (aString,anObject,aDictionary){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  var ctx;
 | 
	
		
			
				|  |  | -return smalltalk.withContext(function($ctx1) { 
var $2,$3,$1;
 | 
	
		
			
				|  |  | -ctx=_st((smalltalk.AIContext || AIContext))._new();
 | 
	
		
			
				|  |  | +function $AIContext(){return smalltalk.AIContext||(typeof AIContext=="undefined"?nil:AIContext)}
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  | +var $2,$3,$1;
 | 
	
		
			
				|  |  | +ctx=_st($AIContext())._new();
 | 
	
		
			
				|  |  |  _st(ctx)._receiver_(anObject);
 | 
	
		
			
				|  |  |  _st(aDictionary)._keysAndValuesDo_((function(key,value){
 | 
	
		
			
				|  |  | -return smalltalk.withContext(function($ctx2) {
return _st(ctx)._localAt_put_(key,value);
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx2) {
 | 
	
		
			
				|  |  | +return _st(ctx)._localAt_put_(key,value);
 | 
	
		
			
				|  |  |  }, function($ctx2) {$ctx2.fillBlock({key:key,value:value},$ctx1)})}));
 | 
	
		
			
				|  |  |  $2=_st(self)._interpreter();
 | 
	
		
			
				|  |  |  _st($2)._context_(ctx);
 | 
	
	
		
			
				|  | @@ -56,8 +63,10 @@ smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "interpret:withArguments:",
 | 
	
		
			
				|  |  |  fn: function (aString,aDictionary){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  | -return smalltalk.withContext(function($ctx1) { 
var $1;
 | 
	
		
			
				|  |  | -$1=_st(self)._interpret_receiver_withArguments_(aString,_st((smalltalk.Object || Object))._new(),aDictionary);
 | 
	
		
			
				|  |  | +function $Object(){return smalltalk.Object||(typeof Object=="undefined"?nil:Object)}
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  | +var $1;
 | 
	
		
			
				|  |  | +$1=_st(self)._interpret_receiver_withArguments_(aString,_st($Object())._new(),aDictionary);
 | 
	
		
			
				|  |  |  return $1;
 | 
	
		
			
				|  |  |  }, function($ctx1) {$ctx1.fill(self,"interpret:withArguments:",{aString:aString,aDictionary:aDictionary},smalltalk.AbstractASTInterpreterTest)})},
 | 
	
		
			
				|  |  |  messageSends: ["interpret:receiver:withArguments:", "new"]}),
 | 
	
	
		
			
				|  | @@ -69,7 +78,8 @@ smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "interpreter",
 | 
	
		
			
				|  |  |  fn: function (){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  | -return smalltalk.withContext(function($ctx1) { 
var $1;
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  | +var $1;
 | 
	
		
			
				|  |  |  $1=_st(self)._subclassResponsibility();
 | 
	
		
			
				|  |  |  return $1;
 | 
	
		
			
				|  |  |  }, function($ctx1) {$ctx1.fill(self,"interpreter",{},smalltalk.AbstractASTInterpreterTest)})},
 | 
	
	
		
			
				|  | @@ -82,8 +92,10 @@ smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "parse:",
 | 
	
		
			
				|  |  |  fn: function (aString){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  | -return smalltalk.withContext(function($ctx1) { 
var $1;
 | 
	
		
			
				|  |  | -$1=_st(_st((smalltalk.Smalltalk || Smalltalk))._current())._parse_(aString);
 | 
	
		
			
				|  |  | +function $Smalltalk(){return smalltalk.Smalltalk||(typeof Smalltalk=="undefined"?nil:Smalltalk)}
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  | +var $1;
 | 
	
		
			
				|  |  | +$1=_st(_st($Smalltalk())._current())._parse_(aString);
 | 
	
		
			
				|  |  |  return $1;
 | 
	
		
			
				|  |  |  }, function($ctx1) {$ctx1.fill(self,"parse:",{aString:aString},smalltalk.AbstractASTInterpreterTest)})},
 | 
	
		
			
				|  |  |  messageSends: ["parse:", "current"]}),
 | 
	
	
		
			
				|  | @@ -95,7 +107,8 @@ smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "parse:forClass:",
 | 
	
		
			
				|  |  |  fn: function (aString,aClass){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  | -return smalltalk.withContext(function($ctx1) { 
var $1;
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  | +var $1;
 | 
	
		
			
				|  |  |  $1=_st(self)._analyze_forClass_(_st(self)._parse_(aString),aClass);
 | 
	
		
			
				|  |  |  return $1;
 | 
	
		
			
				|  |  |  }, function($ctx1) {$ctx1.fill(self,"parse:forClass:",{aString:aString,aClass:aClass},smalltalk.AbstractASTInterpreterTest)})},
 | 
	
	
		
			
				|  | @@ -111,8 +124,10 @@ smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "interpreter",
 | 
	
		
			
				|  |  |  fn: function (){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  | -return smalltalk.withContext(function($ctx1) { 
var $1;
 | 
	
		
			
				|  |  | -$1=_st((smalltalk.ASTInterpreter || ASTInterpreter))._new();
 | 
	
		
			
				|  |  | +function $ASTInterpreter(){return smalltalk.ASTInterpreter||(typeof ASTInterpreter=="undefined"?nil:ASTInterpreter)}
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  | +var $1;
 | 
	
		
			
				|  |  | +$1=_st($ASTInterpreter())._new();
 | 
	
		
			
				|  |  |  return $1;
 | 
	
		
			
				|  |  |  }, function($ctx1) {$ctx1.fill(self,"interpreter",{},smalltalk.ASTInterpreterTest)})},
 | 
	
		
			
				|  |  |  messageSends: ["new"]}),
 | 
	
	
		
			
				|  | @@ -124,7 +139,8 @@ smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "testBinarySend",
 | 
	
		
			
				|  |  |  fn: function (){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  | -return smalltalk.withContext(function($ctx1) { 
_st(self)._assert_equals_(_st(self)._interpret_("foo 2+3+4"),(9));
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  | +_st(self)._assert_equals_(_st(self)._interpret_("foo 2+3+4"),(9));
 | 
	
		
			
				|  |  |  return self}, function($ctx1) {$ctx1.fill(self,"testBinarySend",{},smalltalk.ASTInterpreterTest)})},
 | 
	
		
			
				|  |  |  messageSends: ["assert:equals:", "interpret:"]}),
 | 
	
		
			
				|  |  |  smalltalk.ASTInterpreterTest);
 | 
	
	
		
			
				|  | @@ -135,7 +151,8 @@ smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "testBlockLiteral",
 | 
	
		
			
				|  |  |  fn: function (){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  | -return smalltalk.withContext(function($ctx1) { 
_st(self)._assert_equals_(_st(self)._interpret_("foo ^ true ifTrue: [ 1 ] ifFalse: [ 2 ]"),(1));
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  | +_st(self)._assert_equals_(_st(self)._interpret_("foo ^ true ifTrue: [ 1 ] ifFalse: [ 2 ]"),(1));
 | 
	
		
			
				|  |  |  _st(self)._assert_equals_(_st(self)._interpret_("foo true ifTrue: [ ^ 1 ] ifFalse: [ 2 ]"),(1));
 | 
	
		
			
				|  |  |  _st(self)._assert_equals_(_st(self)._interpret_("foo ^ false ifTrue: [ 1 ] ifFalse: [ 2 ]"),(2));
 | 
	
		
			
				|  |  |  return self}, function($ctx1) {$ctx1.fill(self,"testBlockLiteral",{},smalltalk.ASTInterpreterTest)})},
 | 
	
	
		
			
				|  | @@ -148,7 +165,9 @@ smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "testCascade",
 | 
	
		
			
				|  |  |  fn: function (){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  | -return smalltalk.withContext(function($ctx1) { 
_st(self)._assert_equals_(_st(self)._interpret_("foo ^ OrderedCollection new add: 2; add: 3; yourself"),_st((smalltalk.OrderedCollection || OrderedCollection))._with_with_((2),(3)));
 | 
	
		
			
				|  |  | +function $OrderedCollection(){return smalltalk.OrderedCollection||(typeof OrderedCollection=="undefined"?nil:OrderedCollection)}
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  | +_st(self)._assert_equals_(_st(self)._interpret_("foo ^ OrderedCollection new add: 2; add: 3; yourself"),_st($OrderedCollection())._with_with_((2),(3)));
 | 
	
		
			
				|  |  |  return self}, function($ctx1) {$ctx1.fill(self,"testCascade",{},smalltalk.ASTInterpreterTest)})},
 | 
	
		
			
				|  |  |  messageSends: ["assert:equals:", "interpret:", "with:with:"]}),
 | 
	
		
			
				|  |  |  smalltalk.ASTInterpreterTest);
 | 
	
	
		
			
				|  | @@ -159,7 +178,8 @@ smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "testDynamicArray",
 | 
	
		
			
				|  |  |  fn: function (){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  | -return smalltalk.withContext(function($ctx1) { 
_st(self)._assert_equals_(_st(self)._interpret_("foo ^ {1+1. 2+2}"),[(2), (4)]);
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  | +_st(self)._assert_equals_(_st(self)._interpret_("foo ^ {1+1. 2+2}"),[(2), (4)]);
 | 
	
		
			
				|  |  |  return self}, function($ctx1) {$ctx1.fill(self,"testDynamicArray",{},smalltalk.ASTInterpreterTest)})},
 | 
	
		
			
				|  |  |  messageSends: ["assert:equals:", "interpret:"]}),
 | 
	
		
			
				|  |  |  smalltalk.ASTInterpreterTest);
 | 
	
	
		
			
				|  | @@ -170,7 +190,8 @@ smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "testDynamicDictionary",
 | 
	
		
			
				|  |  |  fn: function (){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  | -return smalltalk.withContext(function($ctx1) { 
_st(self)._assert_equals_(_st(self)._interpret_("foo ^ #{1->1. 2->3}"),smalltalk.HashedCollection._fromPairs_([_st((1)).__minus_gt((1)),_st((2)).__minus_gt((3))]));
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  | +_st(self)._assert_equals_(_st(self)._interpret_("foo ^ #{1->1. 2->3}"),smalltalk.HashedCollection._fromPairs_([_st((1)).__minus_gt((1)),_st((2)).__minus_gt((3))]));
 | 
	
		
			
				|  |  |  return self}, function($ctx1) {$ctx1.fill(self,"testDynamicDictionary",{},smalltalk.ASTInterpreterTest)})},
 | 
	
		
			
				|  |  |  messageSends: ["assert:equals:", "interpret:", "->"]}),
 | 
	
		
			
				|  |  |  smalltalk.ASTInterpreterTest);
 | 
	
	
		
			
				|  | @@ -181,7 +202,8 @@ smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "testInlinedJSStatement",
 | 
	
		
			
				|  |  |  fn: function (){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  | -return smalltalk.withContext(function($ctx1) { 
_st(self)._assert_equals_(_st(self)._interpret_("foo <return 2+3>"),(5));
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  | +_st(self)._assert_equals_(_st(self)._interpret_("foo <return 2+3>"),(5));
 | 
	
		
			
				|  |  |  _st(self)._assert_equals_(_st(self)._interpret_withArguments_("foo: anInteger <return 2 + anInteger>",smalltalk.HashedCollection._fromPairs_([_st("anInteger").__minus_gt((3))])),(5));
 | 
	
		
			
				|  |  |  return self}, function($ctx1) {$ctx1.fill(self,"testInlinedJSStatement",{},smalltalk.ASTInterpreterTest)})},
 | 
	
		
			
				|  |  |  messageSends: ["assert:equals:", "interpret:", "interpret:withArguments:", "->"]}),
 | 
	
	
		
			
				|  | @@ -193,7 +215,8 @@ smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "testInstVarAccess",
 | 
	
		
			
				|  |  |  fn: function (){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  | -return smalltalk.withContext(function($ctx1) { 
_st(self)._assert_equals_(_st(self)._interpret_receiver_withArguments_("foo ^ x",_st((2)).__at((3)),smalltalk.HashedCollection._fromPairs_([])),(2));
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  | +_st(self)._assert_equals_(_st(self)._interpret_receiver_withArguments_("foo ^ x",_st((2)).__at((3)),smalltalk.HashedCollection._fromPairs_([])),(2));
 | 
	
		
			
				|  |  |  return self}, function($ctx1) {$ctx1.fill(self,"testInstVarAccess",{},smalltalk.ASTInterpreterTest)})},
 | 
	
		
			
				|  |  |  messageSends: ["assert:equals:", "interpret:receiver:withArguments:", "@"]}),
 | 
	
		
			
				|  |  |  smalltalk.ASTInterpreterTest);
 | 
	
	
		
			
				|  | @@ -204,7 +227,9 @@ smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "testInstVarAssignment",
 | 
	
		
			
				|  |  |  fn: function (){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  | -return smalltalk.withContext(function($ctx1) { 
_st(self)._assert_equals_(_st(self)._interpret_receiver_withArguments_("foo: anInteger x := anInteger. ^ x",_st((smalltalk.Point || Point))._new(),smalltalk.HashedCollection._fromPairs_([_st("anInteger").__minus_gt((2))])),(2));
 | 
	
		
			
				|  |  | +function $Point(){return smalltalk.Point||(typeof Point=="undefined"?nil:Point)}
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  | +_st(self)._assert_equals_(_st(self)._interpret_receiver_withArguments_("foo: anInteger x := anInteger. ^ x",_st($Point())._new(),smalltalk.HashedCollection._fromPairs_([_st("anInteger").__minus_gt((2))])),(2));
 | 
	
		
			
				|  |  |  return self}, function($ctx1) {$ctx1.fill(self,"testInstVarAssignment",{},smalltalk.ASTInterpreterTest)})},
 | 
	
		
			
				|  |  |  messageSends: ["assert:equals:", "interpret:receiver:withArguments:", "new", "->"]}),
 | 
	
		
			
				|  |  |  smalltalk.ASTInterpreterTest);
 | 
	
	
		
			
				|  | @@ -215,7 +240,8 @@ smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "testNonlocalReturn",
 | 
	
		
			
				|  |  |  fn: function (){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  | -return smalltalk.withContext(function($ctx1) { 
_st(self)._assert_equals_(_st(self)._interpret_("foo true ifTrue: [ ^ 1 ]. ^2"),(1));
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  | +_st(self)._assert_equals_(_st(self)._interpret_("foo true ifTrue: [ ^ 1 ]. ^2"),(1));
 | 
	
		
			
				|  |  |  return self}, function($ctx1) {$ctx1.fill(self,"testNonlocalReturn",{},smalltalk.ASTInterpreterTest)})},
 | 
	
		
			
				|  |  |  messageSends: ["assert:equals:", "interpret:"]}),
 | 
	
		
			
				|  |  |  smalltalk.ASTInterpreterTest);
 | 
	
	
		
			
				|  | @@ -226,7 +252,8 @@ smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "testReceiver",
 | 
	
		
			
				|  |  |  fn: function (){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  | -return smalltalk.withContext(function($ctx1) { 
_st(self)._assert_equals_(_st(self)._interpret_receiver_withArguments_("foo ^ self",_st((2)).__at((3)),smalltalk.HashedCollection._fromPairs_([])),_st((2)).__at((3)));
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  | +_st(self)._assert_equals_(_st(self)._interpret_receiver_withArguments_("foo ^ self",_st((2)).__at((3)),smalltalk.HashedCollection._fromPairs_([])),_st((2)).__at((3)));
 | 
	
		
			
				|  |  |  return self}, function($ctx1) {$ctx1.fill(self,"testReceiver",{},smalltalk.ASTInterpreterTest)})},
 | 
	
		
			
				|  |  |  messageSends: ["assert:equals:", "interpret:receiver:withArguments:", "@"]}),
 | 
	
		
			
				|  |  |  smalltalk.ASTInterpreterTest);
 | 
	
	
		
			
				|  | @@ -237,7 +264,8 @@ smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "testTempAssignment",
 | 
	
		
			
				|  |  |  fn: function (){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  | -return smalltalk.withContext(function($ctx1) { 
_st(self)._assert_equals_(_st(self)._interpret_("foo | a | a := 2. ^ a"),(2));
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  | +_st(self)._assert_equals_(_st(self)._interpret_("foo | a | a := 2. ^ a"),(2));
 | 
	
		
			
				|  |  |  return self}, function($ctx1) {$ctx1.fill(self,"testTempAssignment",{},smalltalk.ASTInterpreterTest)})},
 | 
	
		
			
				|  |  |  messageSends: ["assert:equals:", "interpret:"]}),
 | 
	
		
			
				|  |  |  smalltalk.ASTInterpreterTest);
 | 
	
	
		
			
				|  | @@ -251,10 +279,12 @@ smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "interpreter",
 | 
	
		
			
				|  |  |  fn: function (){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  | -return smalltalk.withContext(function($ctx1) { 
var $2,$1;
 | 
	
		
			
				|  |  | +function $ASTSteppingInterpreter(){return smalltalk.ASTSteppingInterpreter||(typeof ASTSteppingInterpreter=="undefined"?nil:ASTSteppingInterpreter)}
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  | +var $2,$1;
 | 
	
		
			
				|  |  |  $2=self["@interpreter"];
 | 
	
		
			
				|  |  |  if(($receiver = $2) == nil || $receiver == undefined){
 | 
	
		
			
				|  |  | -self["@interpreter"]=_st((smalltalk.ASTSteppingInterpreter || ASTSteppingInterpreter))._new();
 | 
	
		
			
				|  |  | +self["@interpreter"]=_st($ASTSteppingInterpreter())._new();
 | 
	
		
			
				|  |  |  $1=self["@interpreter"];
 | 
	
		
			
				|  |  |  } else {
 | 
	
		
			
				|  |  |  $1=$2;
 | 
	
	
		
			
				|  | @@ -270,7 +300,8 @@ smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "testAtEnd",
 | 
	
		
			
				|  |  |  fn: function (){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  | -return smalltalk.withContext(function($ctx1) { 
_st(self)._interpret_("foo 1 + 2");
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  | +_st(self)._interpret_("foo 1 + 2");
 | 
	
		
			
				|  |  |  _st(self)._deny_(_st(_st(self)._interpreter())._atEnd());
 | 
	
		
			
				|  |  |  _st(_st(self)._interpreter())._step();
 | 
	
		
			
				|  |  |  _st(self)._deny_(_st(_st(self)._interpreter())._atEnd());
 | 
	
	
		
			
				|  | @@ -290,7 +321,8 @@ smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "testMessageSend",
 | 
	
		
			
				|  |  |  fn: function (){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  | -return smalltalk.withContext(function($ctx1) { 
_st(self)._interpret_("foo 1 + 2");
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  | +_st(self)._interpret_("foo 1 + 2");
 | 
	
		
			
				|  |  |  _st(_st(self)._interpreter())._step();
 | 
	
		
			
				|  |  |  _st(_st(self)._interpreter())._step();
 | 
	
		
			
				|  |  |  _st(_st(self)._interpreter())._step();
 | 
	
	
		
			
				|  | @@ -309,7 +341,8 @@ smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "testSimpleStepping",
 | 
	
		
			
				|  |  |  fn: function (){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  | -return smalltalk.withContext(function($ctx1) { 
_st(self)._interpret_("foo 1");
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  | +_st(self)._interpret_("foo 1");
 | 
	
		
			
				|  |  |  _st(_st(self)._interpreter())._step();
 | 
	
		
			
				|  |  |  _st(self)._assert_(_st(_st(_st(self)._interpreter())._result())._isNil());
 | 
	
		
			
				|  |  |  _st(_st(self)._interpreter())._step();
 | 
	
	
		
			
				|  | @@ -327,8 +360,10 @@ smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "codeGeneratorClass",
 | 
	
		
			
				|  |  |  fn: function (){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  | -return smalltalk.withContext(function($ctx1) { 
var $1;
 | 
	
		
			
				|  |  | -$1=(smalltalk.CodeGenerator || CodeGenerator);
 | 
	
		
			
				|  |  | +function $CodeGenerator(){return smalltalk.CodeGenerator||(typeof CodeGenerator=="undefined"?nil:CodeGenerator)}
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  | +var $1;
 | 
	
		
			
				|  |  | +$1=$CodeGenerator();
 | 
	
		
			
				|  |  |  return $1;
 | 
	
		
			
				|  |  |  }, function($ctx1) {$ctx1.fill(self,"codeGeneratorClass",{},smalltalk.CodeGeneratorTest)})},
 | 
	
		
			
				|  |  |  messageSends: []}),
 | 
	
	
		
			
				|  | @@ -340,8 +375,10 @@ smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "compiler",
 | 
	
		
			
				|  |  |  fn: function (){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  | -return smalltalk.withContext(function($ctx1) { 
var $2,$3,$1;
 | 
	
		
			
				|  |  | -$2=_st((smalltalk.Compiler || Compiler))._new();
 | 
	
		
			
				|  |  | +function $Compiler(){return smalltalk.Compiler||(typeof Compiler=="undefined"?nil:Compiler)}
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  | +var $2,$3,$1;
 | 
	
		
			
				|  |  | +$2=_st($Compiler())._new();
 | 
	
		
			
				|  |  |  _st($2)._codeGeneratorClass_(_st(self)._codeGeneratorClass());
 | 
	
		
			
				|  |  |  $3=_st($2)._yourself();
 | 
	
		
			
				|  |  |  $1=$3;
 | 
	
	
		
			
				|  | @@ -356,7 +393,8 @@ smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "setUp",
 | 
	
		
			
				|  |  |  fn: function (){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  | -return smalltalk.withContext(function($ctx1) { 
self["@receiver"]=_st(_st(self)._targetClass())._new();
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  | +self["@receiver"]=_st(_st(self)._targetClass())._new();
 | 
	
		
			
				|  |  |  return self}, function($ctx1) {$ctx1.fill(self,"setUp",{},smalltalk.CodeGeneratorTest)})},
 | 
	
		
			
				|  |  |  messageSends: ["new", "targetClass"]}),
 | 
	
		
			
				|  |  |  smalltalk.CodeGeneratorTest);
 | 
	
	
		
			
				|  | @@ -368,7 +406,8 @@ selector: "should:return:",
 | 
	
		
			
				|  |  |  fn: function (aString,anObject){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  var method,result;
 | 
	
		
			
				|  |  | -return smalltalk.withContext(function($ctx1) { 
method=_st(_st(self)._compiler())._install_forClass_category_(aString,_st(self)._targetClass(),"tests");
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  | +method=_st(_st(self)._compiler())._install_forClass_category_(aString,_st(self)._targetClass(),"tests");
 | 
	
		
			
				|  |  |  result=_st(self["@receiver"])._perform_(_st(method)._selector());
 | 
	
		
			
				|  |  |  _st(_st(self)._targetClass())._removeCompiledMethod_(method);
 | 
	
		
			
				|  |  |  _st(self)._assert_equals_(anObject,result);
 | 
	
	
		
			
				|  | @@ -382,8 +421,10 @@ smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "targetClass",
 | 
	
		
			
				|  |  |  fn: function (){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  | -return smalltalk.withContext(function($ctx1) { 
var $1;
 | 
	
		
			
				|  |  | -$1=(smalltalk.DoIt || DoIt);
 | 
	
		
			
				|  |  | +function $DoIt(){return smalltalk.DoIt||(typeof DoIt=="undefined"?nil:DoIt)}
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  | +var $1;
 | 
	
		
			
				|  |  | +$1=$DoIt();
 | 
	
		
			
				|  |  |  return $1;
 | 
	
		
			
				|  |  |  }, function($ctx1) {$ctx1.fill(self,"targetClass",{},smalltalk.CodeGeneratorTest)})},
 | 
	
		
			
				|  |  |  messageSends: []}),
 | 
	
	
		
			
				|  | @@ -395,7 +436,8 @@ smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "tearDown",
 | 
	
		
			
				|  |  |  fn: function (){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  | -return smalltalk.withContext(function($ctx1) { 
return self}, function($ctx1) {$ctx1.fill(self,"tearDown",{},smalltalk.CodeGeneratorTest)})},
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  | +return self}, function($ctx1) {$ctx1.fill(self,"tearDown",{},smalltalk.CodeGeneratorTest)})},
 | 
	
		
			
				|  |  |  messageSends: []}),
 | 
	
		
			
				|  |  |  smalltalk.CodeGeneratorTest);
 | 
	
		
			
				|  |  |  
 | 
	
	
		
			
				|  | @@ -405,20 +447,35 @@ smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "testAssignment",
 | 
	
		
			
				|  |  |  fn: function (){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  | -return smalltalk.withContext(function($ctx1) { 
_st(self)._should_return_("foo | a | a := true ifTrue: [ 1 ]. ^ a",(1));
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  | +_st(self)._should_return_("foo | a | a := true ifTrue: [ 1 ]. ^ a",(1));
 | 
	
		
			
				|  |  |  _st(self)._should_return_("foo | a | a := false ifTrue: [ 1 ]. ^ a",nil);
 | 
	
		
			
				|  |  |  _st(self)._should_return_("foo | a | ^ a := true ifTrue: [ 1 ]",(1));
 | 
	
		
			
				|  |  |  return self}, function($ctx1) {$ctx1.fill(self,"testAssignment",{},smalltalk.CodeGeneratorTest)})},
 | 
	
		
			
				|  |  |  messageSends: ["should:return:"]}),
 | 
	
		
			
				|  |  |  smalltalk.CodeGeneratorTest);
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  | +smalltalk.addMethod(
 | 
	
		
			
				|  |  | +"_testBackslashSelectors",
 | 
	
		
			
				|  |  | +smalltalk.method({
 | 
	
		
			
				|  |  | +selector: "testBackslashSelectors",
 | 
	
		
			
				|  |  | +fn: function (){
 | 
	
		
			
				|  |  | +var self=this;
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  | +_st(self)._should_return_("\x5c arg ^ 4",(4));
 | 
	
		
			
				|  |  | +_st(self)._should_return_("\x5c\x5c arg ^ 42",(42));
 | 
	
		
			
				|  |  | +return self}, function($ctx1) {$ctx1.fill(self,"testBackslashSelectors",{},smalltalk.CodeGeneratorTest)})},
 | 
	
		
			
				|  |  | +messageSends: ["should:return:"]}),
 | 
	
		
			
				|  |  | +smalltalk.CodeGeneratorTest);
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  |  smalltalk.addMethod(
 | 
	
		
			
				|  |  |  "_testBlockReturn",
 | 
	
		
			
				|  |  |  smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "testBlockReturn",
 | 
	
		
			
				|  |  |  fn: function (){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  | -return smalltalk.withContext(function($ctx1) { 
_st(self)._should_return_("foo ^ #(1 2 3) collect: [ :each | true ifTrue: [ each + 1 ] ]",[(2), (3), (4)]);
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  | +_st(self)._should_return_("foo ^ #(1 2 3) collect: [ :each | true ifTrue: [ each + 1 ] ]",[(2), (3), (4)]);
 | 
	
		
			
				|  |  |  _st(self)._should_return_("foo ^ #(1 2 3) collect: [ :each | false ifFalse: [ each + 1 ] ]",[(2), (3), (4)]);
 | 
	
		
			
				|  |  |  _st(self)._should_return_("foo ^ #(1 2 3) collect: [ :each | each odd ifTrue: [ each + 1 ] ifFalse: [ each - 1 ] ]",[(2), (1), (4)]);
 | 
	
		
			
				|  |  |  return self}, function($ctx1) {$ctx1.fill(self,"testBlockReturn",{},smalltalk.CodeGeneratorTest)})},
 | 
	
	
		
			
				|  | @@ -431,7 +488,8 @@ smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "testCascades",
 | 
	
		
			
				|  |  |  fn: function (){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  | -return smalltalk.withContext(function($ctx1) { 
_st(self)._should_return_("foo ^ Array new add: 3; add: 4; yourself",[(3), (4)]);
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  | +_st(self)._should_return_("foo ^ Array new add: 3; add: 4; yourself",[(3), (4)]);
 | 
	
		
			
				|  |  |  return self}, function($ctx1) {$ctx1.fill(self,"testCascades",{},smalltalk.CodeGeneratorTest)})},
 | 
	
		
			
				|  |  |  messageSends: ["should:return:"]}),
 | 
	
		
			
				|  |  |  smalltalk.CodeGeneratorTest);
 | 
	
	
		
			
				|  | @@ -442,7 +500,8 @@ smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "testDynamicArrayElementsOrdered",
 | 
	
		
			
				|  |  |  fn: function (){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  | -return smalltalk.withContext(function($ctx1) { 
_st(self)._should_return_("foo\x0a\x09| x |\x0a\x09x := 1.\x0a\x09^ { x. true ifTrue: [ x := 2 ] }\x0a",[(1), (2)]);
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  | +_st(self)._should_return_("foo\x0a\x09| x |\x0a\x09x := 1.\x0a\x09^ { x. true ifTrue: [ x := 2 ] }\x0a",[(1), (2)]);
 | 
	
		
			
				|  |  |  return self}, function($ctx1) {$ctx1.fill(self,"testDynamicArrayElementsOrdered",{},smalltalk.CodeGeneratorTest)})},
 | 
	
		
			
				|  |  |  messageSends: ["should:return:"]}),
 | 
	
		
			
				|  |  |  smalltalk.CodeGeneratorTest);
 | 
	
	
		
			
				|  | @@ -453,7 +512,8 @@ smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "testDynamicDictionaryElementsOrdered",
 | 
	
		
			
				|  |  |  fn: function (){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  | -return smalltalk.withContext(function($ctx1) { 
_st(self)._should_return_("foo\x0a\x09| x |\x0a\x09x := 'foo'->1.\x0a\x09^ #{ x. (true ifTrue: [ x := 'bar'->2 ]) }\x0a",smalltalk.HashedCollection._fromPairs_([_st("foo").__minus_gt((1)),_st("bar").__minus_gt((2))]));
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  | +_st(self)._should_return_("foo\x0a\x09| x |\x0a\x09x := 'foo'->1.\x0a\x09^ #{ x. (true ifTrue: [ x := 'bar'->2 ]) }\x0a",smalltalk.HashedCollection._fromPairs_([_st("foo").__minus_gt((1)),_st("bar").__minus_gt((2))]));
 | 
	
		
			
				|  |  |  return self}, function($ctx1) {$ctx1.fill(self,"testDynamicDictionaryElementsOrdered",{},smalltalk.CodeGeneratorTest)})},
 | 
	
		
			
				|  |  |  messageSends: ["should:return:", "->"]}),
 | 
	
		
			
				|  |  |  smalltalk.CodeGeneratorTest);
 | 
	
	
		
			
				|  | @@ -464,7 +524,9 @@ smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "testInnerTemporalDependentElementsOrdered",
 | 
	
		
			
				|  |  |  fn: function (){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  | -return smalltalk.withContext(function($ctx1) { 
_st(self)._should_return_("foo\x0a\x09| x |\x0a\x09x := Array.\x0a\x09^ x with: 'foo'->x with: 'bar'->(true ifTrue: [ x := 2 ])\x0a",[_st("foo").__minus_gt((smalltalk.Array || Array)),_st("bar").__minus_gt((2))]);
 | 
	
		
			
				|  |  | +function $Array(){return smalltalk.Array||(typeof Array=="undefined"?nil:Array)}
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  | +_st(self)._should_return_("foo\x0a\x09| x |\x0a\x09x := Array.\x0a\x09^ x with: 'foo'->x with: 'bar'->(true ifTrue: [ x := 2 ])\x0a",[_st("foo").__minus_gt($Array()),_st("bar").__minus_gt((2))]);
 | 
	
		
			
				|  |  |  _st(self)._should_return_("foo\x0a\x09| x |\x0a\x09x := 1.\x0a\x09^ Array with: 'foo'->x with: 'bar'->(true ifTrue: [ x := 2 ])\x0a",[_st("foo").__minus_gt((1)),_st("bar").__minus_gt((2))]);
 | 
	
		
			
				|  |  |  _st(self)._should_return_("foo\x0a\x09| x |\x0a\x09x := 1.\x0a\x09^ { 'foo'->x. 'bar'->(true ifTrue: [ x := 2 ]) }\x0a",[_st("foo").__minus_gt((1)),_st("bar").__minus_gt((2))]);
 | 
	
		
			
				|  |  |  _st(self)._should_return_("foo\x0a\x09| x |\x0a\x09x := 1.\x0a\x09^ #{ 'foo'->x. 'bar'->(true ifTrue: [ x := 2 ]) }\x0a",smalltalk.HashedCollection._fromPairs_([_st("foo").__minus_gt((1)),_st("bar").__minus_gt((2))]));
 | 
	
	
		
			
				|  | @@ -478,14 +540,15 @@ smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "testLiterals",
 | 
	
		
			
				|  |  |  fn: function (){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  | -return smalltalk.withContext(function($ctx1) { 
_st(self)._should_return_("foo ^ 1",(1));
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  | +_st(self)._should_return_("foo ^ 1",(1));
 | 
	
		
			
				|  |  |  _st(self)._should_return_("foo ^ 'hello'","hello");
 | 
	
		
			
				|  |  |  _st(self)._should_return_("foo ^ #(1 2 3 4)",[(1), (2), (3), (4)]);
 | 
	
		
			
				|  |  |  _st(self)._should_return_("foo ^ {1. [:x | x ] value: 2. 3. [4] value}",[(1), (2), (3), (4)]);
 | 
	
		
			
				|  |  |  _st(self)._should_return_("foo ^ true",true);
 | 
	
		
			
				|  |  |  _st(self)._should_return_("foo ^ false",false);
 | 
	
		
			
				|  |  |  _st(self)._should_return_("foo ^ #{1->2. 3->4}",smalltalk.HashedCollection._fromPairs_([_st((1)).__minus_gt((2)),_st((3)).__minus_gt((4))]));
 | 
	
		
			
				|  |  | -_st(self)._should_return_("foo ^ #hello",smalltalk.symbolFor("hello"));
 | 
	
		
			
				|  |  | +_st(self)._should_return_("foo ^ #hello","hello");
 | 
	
		
			
				|  |  |  _st(self)._should_return_("foo ^ -123.456",(-123.456));
 | 
	
		
			
				|  |  |  return self}, function($ctx1) {$ctx1.fill(self,"testLiterals",{},smalltalk.CodeGeneratorTest)})},
 | 
	
		
			
				|  |  |  messageSends: ["should:return:", "->"]}),
 | 
	
	
		
			
				|  | @@ -497,7 +560,8 @@ smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "testLocalReturn",
 | 
	
		
			
				|  |  |  fn: function (){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  | -return smalltalk.withContext(function($ctx1) { 
_st(self)._should_return_("foo ^ 1",(1));
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  | +_st(self)._should_return_("foo ^ 1",(1));
 | 
	
		
			
				|  |  |  _st(self)._should_return_("foo ^ 1 + 1",(2));
 | 
	
		
			
				|  |  |  _st(self)._should_return_("foo ",self["@receiver"]);
 | 
	
		
			
				|  |  |  _st(self)._should_return_("foo self asString",self["@receiver"]);
 | 
	
	
		
			
				|  | @@ -512,7 +576,8 @@ smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "testMessageSends",
 | 
	
		
			
				|  |  |  fn: function (){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  | -return smalltalk.withContext(function($ctx1) { 
_st(self)._should_return_("foo ^ 1 asString","1");
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  | +_st(self)._should_return_("foo ^ 1 asString","1");
 | 
	
		
			
				|  |  |  _st(self)._should_return_("foo ^ 1 + 1",(2));
 | 
	
		
			
				|  |  |  _st(self)._should_return_("foo ^ 1 + 2 * 3",(9));
 | 
	
		
			
				|  |  |  _st(self)._should_return_("foo ^ 1 to: 3",[(1), (2), (3)]);
 | 
	
	
		
			
				|  | @@ -527,7 +592,8 @@ smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "testMutableLiterals",
 | 
	
		
			
				|  |  |  fn: function (){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  | -return smalltalk.withContext(function($ctx1) { 
_st(self)._should_return_("foo ^ #( 1 2 ) at: 1 put: 3; yourself",[(3), (2)]);
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  | +_st(self)._should_return_("foo ^ #( 1 2 ) at: 1 put: 3; yourself",[(3), (2)]);
 | 
	
		
			
				|  |  |  return self}, function($ctx1) {$ctx1.fill(self,"testMutableLiterals",{},smalltalk.CodeGeneratorTest)})},
 | 
	
		
			
				|  |  |  messageSends: ["should:return:"]}),
 | 
	
		
			
				|  |  |  smalltalk.CodeGeneratorTest);
 | 
	
	
		
			
				|  | @@ -538,7 +604,8 @@ smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "testNestedIfTrue",
 | 
	
		
			
				|  |  |  fn: function (){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  | -return smalltalk.withContext(function($ctx1) { 
_st(self)._should_return_("foo ^ true ifTrue: [ false ifFalse: [ 1 ] ]",(1));
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  | +_st(self)._should_return_("foo ^ true ifTrue: [ false ifFalse: [ 1 ] ]",(1));
 | 
	
		
			
				|  |  |  _st(self)._should_return_("foo ^ true ifTrue: [ false ifTrue: [ 1 ] ]",nil);
 | 
	
		
			
				|  |  |  _st(self)._should_return_("foo true ifTrue: [ false ifFalse: [ ^ 1 ] ]",(1));
 | 
	
		
			
				|  |  |  _st(self)._should_return_("foo true ifTrue: [ false ifTrue: [ ^ 1 ] ]",self["@receiver"]);
 | 
	
	
		
			
				|  | @@ -552,7 +619,8 @@ smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "testNonLocalReturn",
 | 
	
		
			
				|  |  |  fn: function (){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  | -return smalltalk.withContext(function($ctx1) { 
_st(self)._should_return_("foo [ ^ 1 ] value",(1));
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  | +_st(self)._should_return_("foo [ ^ 1 ] value",(1));
 | 
	
		
			
				|  |  |  _st(self)._should_return_("foo [ ^ 1 + 1 ] value",(2));
 | 
	
		
			
				|  |  |  _st(self)._should_return_("foo | a b | a := 1. b := 2. [ ^ a + b ] value. self halt",(3));
 | 
	
		
			
				|  |  |  _st(self)._should_return_("foo [ :x | ^ x + x ] value: 4. ^ 2",(8));
 | 
	
	
		
			
				|  | @@ -560,14 +628,29 @@ return self}, function($ctx1) {$ctx1.fill(self,"testNonLocalReturn",{},smalltalk
 | 
	
		
			
				|  |  |  messageSends: ["should:return:"]}),
 | 
	
		
			
				|  |  |  smalltalk.CodeGeneratorTest);
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  | +smalltalk.addMethod(
 | 
	
		
			
				|  |  | +"_testPascalCaseGlobal",
 | 
	
		
			
				|  |  | +smalltalk.method({
 | 
	
		
			
				|  |  | +selector: "testPascalCaseGlobal",
 | 
	
		
			
				|  |  | +fn: function (){
 | 
	
		
			
				|  |  | +var self=this;
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  | +_st(self)._should_return_("foo ^Object",_st(smalltalk)._at_("Object"));
 | 
	
		
			
				|  |  | +_st(self)._should_return_("foo ^NonExistent",nil);
 | 
	
		
			
				|  |  | +return self}, function($ctx1) {$ctx1.fill(self,"testPascalCaseGlobal",{},smalltalk.CodeGeneratorTest)})},
 | 
	
		
			
				|  |  | +messageSends: ["should:return:", "at:"]}),
 | 
	
		
			
				|  |  | +smalltalk.CodeGeneratorTest);
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  |  smalltalk.addMethod(
 | 
	
		
			
				|  |  |  "_testSendReceiverAndArgumentsOrdered",
 | 
	
		
			
				|  |  |  smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "testSendReceiverAndArgumentsOrdered",
 | 
	
		
			
				|  |  |  fn: function (){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  | -return smalltalk.withContext(function($ctx1) { 
_st(self)._should_return_("foo\x0a\x09| x |\x0a\x09x := 1.\x0a\x09^ Array with: x with: (true ifTrue: [ x := 2 ])\x0a",[(1), (2)]);
 | 
	
		
			
				|  |  | -_st(self)._should_return_("foo\x0a\x09| x |\x0a\x09x := Array.\x0a\x09^ x with: x with: (true ifTrue: [ x := 2 ])\x0a",[(smalltalk.Array || Array),(2)]);
 | 
	
		
			
				|  |  | +function $Array(){return smalltalk.Array||(typeof Array=="undefined"?nil:Array)}
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  | +_st(self)._should_return_("foo\x0a\x09| x |\x0a\x09x := 1.\x0a\x09^ Array with: x with: (true ifTrue: [ x := 2 ])\x0a",[(1), (2)]);
 | 
	
		
			
				|  |  | +_st(self)._should_return_("foo\x0a\x09| x |\x0a\x09x := Array.\x0a\x09^ x with: x with: (true ifTrue: [ x := 2 ])\x0a",[$Array(),(2)]);
 | 
	
		
			
				|  |  |  return self}, function($ctx1) {$ctx1.fill(self,"testSendReceiverAndArgumentsOrdered",{},smalltalk.CodeGeneratorTest)})},
 | 
	
		
			
				|  |  |  messageSends: ["should:return:"]}),
 | 
	
		
			
				|  |  |  smalltalk.CodeGeneratorTest);
 | 
	
	
		
			
				|  | @@ -578,7 +661,8 @@ smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "testifFalse",
 | 
	
		
			
				|  |  |  fn: function (){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  | -return smalltalk.withContext(function($ctx1) { 
_st(self)._should_return_("foo true ifFalse: [ ^ 1 ]",self["@receiver"]);
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  | +_st(self)._should_return_("foo true ifFalse: [ ^ 1 ]",self["@receiver"]);
 | 
	
		
			
				|  |  |  _st(self)._should_return_("foo false ifFalse: [ ^ 2 ]",(2));
 | 
	
		
			
				|  |  |  _st(self)._should_return_("foo ^ true ifFalse: [ 1 ]",nil);
 | 
	
		
			
				|  |  |  _st(self)._should_return_("foo ^ false ifFalse: [ 2 ]",(2));
 | 
	
	
		
			
				|  | @@ -592,7 +676,8 @@ smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "testifFalseIfTrue",
 | 
	
		
			
				|  |  |  fn: function (){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  | -return smalltalk.withContext(function($ctx1) { 
_st(self)._should_return_("foo true ifFalse: [ ^ 1 ] ifTrue: [ ^ 2 ]",(2));
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  | +_st(self)._should_return_("foo true ifFalse: [ ^ 1 ] ifTrue: [ ^ 2 ]",(2));
 | 
	
		
			
				|  |  |  _st(self)._should_return_("foo false ifFalse: [ ^ 2 ] ifTrue: [ ^1 ]",(2));
 | 
	
		
			
				|  |  |  _st(self)._should_return_("foo ^ true ifFalse: [ 1 ] ifTrue: [ 2 ]",(2));
 | 
	
		
			
				|  |  |  _st(self)._should_return_("foo ^ false ifFalse: [ 2 ] ifTrue: [ 1 ]",(2));
 | 
	
	
		
			
				|  | @@ -606,7 +691,8 @@ smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "testifNil",
 | 
	
		
			
				|  |  |  fn: function (){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  | -return smalltalk.withContext(function($ctx1) { 
_st(self)._should_return_("foo ^ 1 ifNil: [ 2 ]",(1));
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  | +_st(self)._should_return_("foo ^ 1 ifNil: [ 2 ]",(1));
 | 
	
		
			
				|  |  |  _st(self)._should_return_("foo ^ nil ifNil: [ 2 ]",(2));
 | 
	
		
			
				|  |  |  _st(self)._should_return_("foo 1 ifNil: [ ^ 2 ]",self["@receiver"]);
 | 
	
		
			
				|  |  |  _st(self)._should_return_("foo nil ifNil: [ ^ 2 ]",(2));
 | 
	
	
		
			
				|  | @@ -620,7 +706,8 @@ smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "testifNilIfNotNil",
 | 
	
		
			
				|  |  |  fn: function (){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  | -return smalltalk.withContext(function($ctx1) { 
_st(self)._should_return_("foo ^ 1 ifNil: [ 2 ] ifNotNil: [ 3 ]",(3));
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  | +_st(self)._should_return_("foo ^ 1 ifNil: [ 2 ] ifNotNil: [ 3 ]",(3));
 | 
	
		
			
				|  |  |  _st(self)._should_return_("foo ^ nil ifNil: [ 2 ] ifNotNil: [ 3 ]",(2));
 | 
	
		
			
				|  |  |  _st(self)._should_return_("foo 1 ifNil: [ ^ 2 ] ifNotNil: [ ^3 ]",(3));
 | 
	
		
			
				|  |  |  _st(self)._should_return_("foo nil ifNil: [ ^ 2 ] ifNotNil: [ ^3 ]",(2));
 | 
	
	
		
			
				|  | @@ -634,7 +721,8 @@ smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "testifNotNil",
 | 
	
		
			
				|  |  |  fn: function (){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  | -return smalltalk.withContext(function($ctx1) { 
_st(self)._should_return_("foo ^ 1 ifNotNil: [ 2 ]",(2));
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  | +_st(self)._should_return_("foo ^ 1 ifNotNil: [ 2 ]",(2));
 | 
	
		
			
				|  |  |  _st(self)._should_return_("foo ^ nil ifNotNil: [ 2 ]",nil);
 | 
	
		
			
				|  |  |  _st(self)._should_return_("foo 1 ifNotNil: [ ^ 2 ]",(2));
 | 
	
		
			
				|  |  |  _st(self)._should_return_("foo nil ifNotNil: [ ^ 2 ]",self["@receiver"]);
 | 
	
	
		
			
				|  | @@ -642,13 +730,31 @@ return self}, function($ctx1) {$ctx1.fill(self,"testifNotNil",{},smalltalk.CodeG
 | 
	
		
			
				|  |  |  messageSends: ["should:return:"]}),
 | 
	
		
			
				|  |  |  smalltalk.CodeGeneratorTest);
 | 
	
		
			
				|  |  |  
 | 
	
		
			
				|  |  | +smalltalk.addMethod(
 | 
	
		
			
				|  |  | +"_testifNotNilWithArgument",
 | 
	
		
			
				|  |  | +smalltalk.method({
 | 
	
		
			
				|  |  | +selector: "testifNotNilWithArgument",
 | 
	
		
			
				|  |  | +fn: function (){
 | 
	
		
			
				|  |  | +var self=this;
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  | +_st(self)._should_return_("foo ^ 1 ifNotNil: [ :val | val + 2 ]",(3));
 | 
	
		
			
				|  |  | +_st(self)._should_return_("foo ^ nil ifNotNil: [ :val | val + 2 ]",nil);
 | 
	
		
			
				|  |  | +_st(self)._should_return_("foo ^ 1 ifNil: [ 5 ] ifNotNil: [ :val | val + 2 ]",(3));
 | 
	
		
			
				|  |  | +_st(self)._should_return_("foo ^ nil ifNil: [ 5 ] ifNotNil: [ :val | val + 2 ]",(5));
 | 
	
		
			
				|  |  | +_st(self)._should_return_("foo ^ 1 ifNotNil: [ :val | val + 2 ] ifNil: [ 5 ]",(3));
 | 
	
		
			
				|  |  | +_st(self)._should_return_("foo ^ nil ifNotNil: [ :val | val + 2 ] ifNil: [ 5 ]",(5));
 | 
	
		
			
				|  |  | +return self}, function($ctx1) {$ctx1.fill(self,"testifNotNilWithArgument",{},smalltalk.CodeGeneratorTest)})},
 | 
	
		
			
				|  |  | +messageSends: ["should:return:"]}),
 | 
	
		
			
				|  |  | +smalltalk.CodeGeneratorTest);
 | 
	
		
			
				|  |  | +
 | 
	
		
			
				|  |  |  smalltalk.addMethod(
 | 
	
		
			
				|  |  |  "_testifTrue",
 | 
	
		
			
				|  |  |  smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "testifTrue",
 | 
	
		
			
				|  |  |  fn: function (){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  | -return smalltalk.withContext(function($ctx1) { 
_st(self)._should_return_("foo false ifTrue: [ ^ 1 ]",self["@receiver"]);
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  | +_st(self)._should_return_("foo false ifTrue: [ ^ 1 ]",self["@receiver"]);
 | 
	
		
			
				|  |  |  _st(self)._should_return_("foo true ifTrue: [ ^ 2 ]",(2));
 | 
	
		
			
				|  |  |  _st(self)._should_return_("foo ^ false ifTrue: [ 1 ]",nil);
 | 
	
		
			
				|  |  |  _st(self)._should_return_("foo ^ true ifTrue: [ 2 ]",(2));
 | 
	
	
		
			
				|  | @@ -662,7 +768,8 @@ smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "testifTrueIfFalse",
 | 
	
		
			
				|  |  |  fn: function (){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  | -return smalltalk.withContext(function($ctx1) { 
_st(self)._should_return_("foo false ifTrue: [ ^ 1 ] ifFalse: [ ^2 ]",(2));
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  | +_st(self)._should_return_("foo false ifTrue: [ ^ 1 ] ifFalse: [ ^2 ]",(2));
 | 
	
		
			
				|  |  |  _st(self)._should_return_("foo true ifTrue: [ ^ 1 ] ifFalse: [ ^ 2 ]",(1));
 | 
	
		
			
				|  |  |  _st(self)._should_return_("foo ^ false ifTrue: [ 2 ] ifFalse: [ 1 ]",(1));
 | 
	
		
			
				|  |  |  _st(self)._should_return_("foo ^ true ifTrue: [ 2 ] ifFalse: [ 1 ]",(2));
 | 
	
	
		
			
				|  | @@ -679,8 +786,10 @@ smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "codeGeneratorClass",
 | 
	
		
			
				|  |  |  fn: function (){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  | -return smalltalk.withContext(function($ctx1) { 
var $1;
 | 
	
		
			
				|  |  | -$1=(smalltalk.InliningCodeGenerator || InliningCodeGenerator);
 | 
	
		
			
				|  |  | +function $InliningCodeGenerator(){return smalltalk.InliningCodeGenerator||(typeof InliningCodeGenerator=="undefined"?nil:InliningCodeGenerator)}
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  | +var $1;
 | 
	
		
			
				|  |  | +$1=$InliningCodeGenerator();
 | 
	
		
			
				|  |  |  return $1;
 | 
	
		
			
				|  |  |  }, function($ctx1) {$ctx1.fill(self,"codeGeneratorClass",{},smalltalk.InliningCodeGeneratorTest)})},
 | 
	
		
			
				|  |  |  messageSends: []}),
 | 
	
	
		
			
				|  | @@ -696,12 +805,15 @@ selector: "testClassRefVar",
 | 
	
		
			
				|  |  |  fn: function (){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  var node;
 | 
	
		
			
				|  |  | -return smalltalk.withContext(function($ctx1) { 
var $1,$2;
 | 
	
		
			
				|  |  | -$1=_st((smalltalk.ClassReferenceNode || ClassReferenceNode))._new();
 | 
	
		
			
				|  |  | +function $ClassReferenceNode(){return smalltalk.ClassReferenceNode||(typeof ClassReferenceNode=="undefined"?nil:ClassReferenceNode)}
 | 
	
		
			
				|  |  | +function $SemanticAnalyzer(){return smalltalk.SemanticAnalyzer||(typeof SemanticAnalyzer=="undefined"?nil:SemanticAnalyzer)}
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  | +var $1,$2;
 | 
	
		
			
				|  |  | +$1=_st($ClassReferenceNode())._new();
 | 
	
		
			
				|  |  |  _st($1)._value_("Object");
 | 
	
		
			
				|  |  |  $2=_st($1)._yourself();
 | 
	
		
			
				|  |  |  node=$2;
 | 
	
		
			
				|  |  | -_st(_st((smalltalk.SemanticAnalyzer || SemanticAnalyzer))._new())._visit_(node);
 | 
	
		
			
				|  |  | +_st(_st($SemanticAnalyzer())._new())._visit_(node);
 | 
	
		
			
				|  |  |  _st(self)._assert_(_st(_st(node)._binding())._isClassRefVar());
 | 
	
		
			
				|  |  |  return self}, function($ctx1) {$ctx1.fill(self,"testClassRefVar",{node:node},smalltalk.ScopeVarTest)})},
 | 
	
		
			
				|  |  |  messageSends: ["value:", "new", "yourself", "visit:", "assert:", "isClassRefVar", "binding"]}),
 | 
	
	
		
			
				|  | @@ -714,12 +826,15 @@ selector: "testInstanceVar",
 | 
	
		
			
				|  |  |  fn: function (){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  var node,scope;
 | 
	
		
			
				|  |  | -return smalltalk.withContext(function($ctx1) { 
var $1,$2;
 | 
	
		
			
				|  |  | -$1=_st((smalltalk.VariableNode || VariableNode))._new();
 | 
	
		
			
				|  |  | +function $VariableNode(){return smalltalk.VariableNode||(typeof VariableNode=="undefined"?nil:VariableNode)}
 | 
	
		
			
				|  |  | +function $MethodLexicalScope(){return smalltalk.MethodLexicalScope||(typeof MethodLexicalScope=="undefined"?nil:MethodLexicalScope)}
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  | +var $1,$2;
 | 
	
		
			
				|  |  | +$1=_st($VariableNode())._new();
 | 
	
		
			
				|  |  |  _st($1)._value_("bzzz");
 | 
	
		
			
				|  |  |  $2=_st($1)._yourself();
 | 
	
		
			
				|  |  |  node=$2;
 | 
	
		
			
				|  |  | -scope=_st((smalltalk.MethodLexicalScope || MethodLexicalScope))._new();
 | 
	
		
			
				|  |  | +scope=_st($MethodLexicalScope())._new();
 | 
	
		
			
				|  |  |  _st(scope)._addIVar_("bzzz");
 | 
	
		
			
				|  |  |  _st(self)._assert_(_st(_st(scope)._bindingFor_(node))._isInstanceVar());
 | 
	
		
			
				|  |  |  return self}, function($ctx1) {$ctx1.fill(self,"testInstanceVar",{node:node,scope:scope},smalltalk.ScopeVarTest)})},
 | 
	
	
		
			
				|  | @@ -733,15 +848,19 @@ selector: "testPseudoVar",
 | 
	
		
			
				|  |  |  fn: function (){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  var node,pseudoVars;
 | 
	
		
			
				|  |  | -return smalltalk.withContext(function($ctx1) { 
var $1,$2;
 | 
	
		
			
				|  |  | +function $VariableNode(){return smalltalk.VariableNode||(typeof VariableNode=="undefined"?nil:VariableNode)}
 | 
	
		
			
				|  |  | +function $MethodLexicalScope(){return smalltalk.MethodLexicalScope||(typeof MethodLexicalScope=="undefined"?nil:MethodLexicalScope)}
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  | +var $1,$2;
 | 
	
		
			
				|  |  |  pseudoVars=["self", "super", "true", "false", "nil"];
 | 
	
		
			
				|  |  |  _st(pseudoVars)._do_((function(each){
 | 
	
		
			
				|  |  | -return smalltalk.withContext(function($ctx2) {
$1=_st((smalltalk.VariableNode || VariableNode))._new();
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx2) {
 | 
	
		
			
				|  |  | +$1=_st($VariableNode())._new();
 | 
	
		
			
				|  |  |  _st($1)._value_(each);
 | 
	
		
			
				|  |  |  $2=_st($1)._yourself();
 | 
	
		
			
				|  |  |  node=$2;
 | 
	
		
			
				|  |  |  node;
 | 
	
		
			
				|  |  | -return _st(self)._assert_(_st(_st(_st((smalltalk.MethodLexicalScope || MethodLexicalScope))._new())._bindingFor_(node))._isPseudoVar());
 | 
	
		
			
				|  |  | +return _st(self)._assert_(_st(_st(_st($MethodLexicalScope())._new())._bindingFor_(node))._isPseudoVar());
 | 
	
		
			
				|  |  |  }, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1)})}));
 | 
	
		
			
				|  |  |  return self}, function($ctx1) {$ctx1.fill(self,"testPseudoVar",{node:node,pseudoVars:pseudoVars},smalltalk.ScopeVarTest)})},
 | 
	
		
			
				|  |  |  messageSends: ["do:", "value:", "new", "yourself", "assert:", "isPseudoVar", "bindingFor:"]}),
 | 
	
	
		
			
				|  | @@ -754,12 +873,15 @@ selector: "testTempVar",
 | 
	
		
			
				|  |  |  fn: function (){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  var node,scope;
 | 
	
		
			
				|  |  | -return smalltalk.withContext(function($ctx1) { 
var $1,$2;
 | 
	
		
			
				|  |  | -$1=_st((smalltalk.VariableNode || VariableNode))._new();
 | 
	
		
			
				|  |  | +function $VariableNode(){return smalltalk.VariableNode||(typeof VariableNode=="undefined"?nil:VariableNode)}
 | 
	
		
			
				|  |  | +function $MethodLexicalScope(){return smalltalk.MethodLexicalScope||(typeof MethodLexicalScope=="undefined"?nil:MethodLexicalScope)}
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  | +var $1,$2;
 | 
	
		
			
				|  |  | +$1=_st($VariableNode())._new();
 | 
	
		
			
				|  |  |  _st($1)._value_("bzzz");
 | 
	
		
			
				|  |  |  $2=_st($1)._yourself();
 | 
	
		
			
				|  |  |  node=$2;
 | 
	
		
			
				|  |  | -scope=_st((smalltalk.MethodLexicalScope || MethodLexicalScope))._new();
 | 
	
		
			
				|  |  | +scope=_st($MethodLexicalScope())._new();
 | 
	
		
			
				|  |  |  _st(scope)._addTemp_("bzzz");
 | 
	
		
			
				|  |  |  _st(self)._assert_(_st(_st(scope)._bindingFor_(node))._isTempVar());
 | 
	
		
			
				|  |  |  return self}, function($ctx1) {$ctx1.fill(self,"testTempVar",{node:node,scope:scope},smalltalk.ScopeVarTest)})},
 | 
	
	
		
			
				|  | @@ -773,12 +895,15 @@ selector: "testUnknownVar",
 | 
	
		
			
				|  |  |  fn: function (){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  var node;
 | 
	
		
			
				|  |  | -return smalltalk.withContext(function($ctx1) { 
var $1,$2;
 | 
	
		
			
				|  |  | -$1=_st((smalltalk.VariableNode || VariableNode))._new();
 | 
	
		
			
				|  |  | +function $VariableNode(){return smalltalk.VariableNode||(typeof VariableNode=="undefined"?nil:VariableNode)}
 | 
	
		
			
				|  |  | +function $MethodLexicalScope(){return smalltalk.MethodLexicalScope||(typeof MethodLexicalScope=="undefined"?nil:MethodLexicalScope)}
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  | +var $1,$2;
 | 
	
		
			
				|  |  | +$1=_st($VariableNode())._new();
 | 
	
		
			
				|  |  |  _st($1)._value_("bzzz");
 | 
	
		
			
				|  |  |  $2=_st($1)._yourself();
 | 
	
		
			
				|  |  |  node=$2;
 | 
	
		
			
				|  |  | -_st(self)._assert_(_st(_st(_st((smalltalk.MethodLexicalScope || MethodLexicalScope))._new())._bindingFor_(node))._isNil());
 | 
	
		
			
				|  |  | +_st(self)._assert_(_st(_st(_st($MethodLexicalScope())._new())._bindingFor_(node))._isNil());
 | 
	
		
			
				|  |  |  return self}, function($ctx1) {$ctx1.fill(self,"testUnknownVar",{node:node},smalltalk.ScopeVarTest)})},
 | 
	
		
			
				|  |  |  messageSends: ["value:", "new", "yourself", "assert:", "isNil", "bindingFor:"]}),
 | 
	
		
			
				|  |  |  smalltalk.ScopeVarTest);
 | 
	
	
		
			
				|  | @@ -792,7 +917,10 @@ smalltalk.method({
 | 
	
		
			
				|  |  |  selector: "setUp",
 | 
	
		
			
				|  |  |  fn: function (){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  | -return smalltalk.withContext(function($ctx1) { 
self["@analyzer"]=_st((smalltalk.SemanticAnalyzer || SemanticAnalyzer))._on_((smalltalk.Object || Object));
 | 
	
		
			
				|  |  | +function $Object(){return smalltalk.Object||(typeof Object=="undefined"?nil:Object)}
 | 
	
		
			
				|  |  | +function $SemanticAnalyzer(){return smalltalk.SemanticAnalyzer||(typeof SemanticAnalyzer=="undefined"?nil:SemanticAnalyzer)}
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  | +self["@analyzer"]=_st($SemanticAnalyzer())._on_($Object());
 | 
	
		
			
				|  |  |  return self}, function($ctx1) {$ctx1.fill(self,"setUp",{},smalltalk.SemanticAnalyzerTest)})},
 | 
	
		
			
				|  |  |  messageSends: ["on:"]}),
 | 
	
		
			
				|  |  |  smalltalk.SemanticAnalyzerTest);
 | 
	
	
		
			
				|  | @@ -804,11 +932,14 @@ selector: "testAssignment",
 | 
	
		
			
				|  |  |  fn: function (){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  var src,ast;
 | 
	
		
			
				|  |  | -return smalltalk.withContext(function($ctx1) { 
src="foo self := 1";
 | 
	
		
			
				|  |  | +function $InvalidAssignmentError(){return smalltalk.InvalidAssignmentError||(typeof InvalidAssignmentError=="undefined"?nil:InvalidAssignmentError)}
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  | +src="foo self := 1";
 | 
	
		
			
				|  |  |  ast=_st(smalltalk)._parse_(src);
 | 
	
		
			
				|  |  |  _st(self)._should_raise_((function(){
 | 
	
		
			
				|  |  | -return smalltalk.withContext(function($ctx2) {
return _st(self["@analyzer"])._visit_(ast);
 | 
	
		
			
				|  |  | -}, function($ctx2) {$ctx2.fillBlock({},$ctx1)})}),(smalltalk.InvalidAssignmentError || InvalidAssignmentError));
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx2) {
 | 
	
		
			
				|  |  | +return _st(self["@analyzer"])._visit_(ast);
 | 
	
		
			
				|  |  | +}, function($ctx2) {$ctx2.fillBlock({},$ctx1)})}),$InvalidAssignmentError());
 | 
	
		
			
				|  |  |  return self}, function($ctx1) {$ctx1.fill(self,"testAssignment",{src:src,ast:ast},smalltalk.SemanticAnalyzerTest)})},
 | 
	
		
			
				|  |  |  messageSends: ["parse:", "should:raise:", "visit:"]}),
 | 
	
		
			
				|  |  |  smalltalk.SemanticAnalyzerTest);
 | 
	
	
		
			
				|  | @@ -820,7 +951,8 @@ selector: "testNonLocalReturn",
 | 
	
		
			
				|  |  |  fn: function (){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  var src,ast;
 | 
	
		
			
				|  |  | -return smalltalk.withContext(function($ctx1) { 
src="foo | a | a + 1. ^ a";
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  | +src="foo | a | a + 1. ^ a";
 | 
	
		
			
				|  |  |  ast=_st(smalltalk)._parse_(src);
 | 
	
		
			
				|  |  |  _st(self["@analyzer"])._visit_(ast);
 | 
	
		
			
				|  |  |  _st(self)._deny_(_st(_st(ast)._scope())._hasNonLocalReturn());
 | 
	
	
		
			
				|  | @@ -835,7 +967,8 @@ selector: "testNonLocalReturn2",
 | 
	
		
			
				|  |  |  fn: function (){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  var src,ast;
 | 
	
		
			
				|  |  | -return smalltalk.withContext(function($ctx1) { 
src="foo | a | a + 1. [ [ ^ a] ]";
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  | +src="foo | a | a + 1. [ [ ^ a] ]";
 | 
	
		
			
				|  |  |  ast=_st(smalltalk)._parse_(src);
 | 
	
		
			
				|  |  |  _st(self["@analyzer"])._visit_(ast);
 | 
	
		
			
				|  |  |  _st(self)._assert_(_st(_st(ast)._scope())._hasNonLocalReturn());
 | 
	
	
		
			
				|  | @@ -850,7 +983,8 @@ selector: "testScope",
 | 
	
		
			
				|  |  |  fn: function (){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  var src,ast;
 | 
	
		
			
				|  |  | -return smalltalk.withContext(function($ctx1) { 
src="foo | a | a + 1. [ | b | b := a ]";
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  | +src="foo | a | a + 1. [ | b | b := a ]";
 | 
	
		
			
				|  |  |  ast=_st(smalltalk)._parse_(src);
 | 
	
		
			
				|  |  |  _st(self["@analyzer"])._visit_(ast);
 | 
	
		
			
				|  |  |  _st(self)._deny_(_st(_st(_st(_st(_st(_st(ast)._nodes())._first())._nodes())._last())._scope()).__eq_eq(_st(ast)._scope()));
 | 
	
	
		
			
				|  | @@ -865,7 +999,8 @@ selector: "testScope2",
 | 
	
		
			
				|  |  |  fn: function (){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  var src,ast;
 | 
	
		
			
				|  |  | -return smalltalk.withContext(function($ctx1) { 
src="foo | a | a + 1. [ [ | b | b := a ] ]";
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  | +src="foo | a | a + 1. [ [ | b | b := a ] ]";
 | 
	
		
			
				|  |  |  ast=_st(smalltalk)._parse_(src);
 | 
	
		
			
				|  |  |  _st(self["@analyzer"])._visit_(ast);
 | 
	
		
			
				|  |  |  _st(self)._deny_(_st(_st(_st(_st(_st(_st(_st(_st(_st(_st(ast)._nodes())._first())._nodes())._last())._nodes())._first())._nodes())._first())._scope()).__eq_eq(_st(ast)._scope()));
 | 
	
	
		
			
				|  | @@ -880,7 +1015,8 @@ selector: "testScopeLevel",
 | 
	
		
			
				|  |  |  fn: function (){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  var src,ast;
 | 
	
		
			
				|  |  | -return smalltalk.withContext(function($ctx1) { 
src="foo | a | a + 1. [ [ | b | b := a ] ]";
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  | +src="foo | a | a + 1. [ [ | b | b := a ] ]";
 | 
	
		
			
				|  |  |  ast=_st(smalltalk)._parse_(src);
 | 
	
		
			
				|  |  |  _st(self["@analyzer"])._visit_(ast);
 | 
	
		
			
				|  |  |  _st(self)._assert_equals_(_st(_st(ast)._scope())._scopeLevel(),(1));
 | 
	
	
		
			
				|  | @@ -896,11 +1032,14 @@ selector: "testUnknownVariables",
 | 
	
		
			
				|  |  |  fn: function (){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  var src,ast;
 | 
	
		
			
				|  |  | -return smalltalk.withContext(function($ctx1) { 
src="foo | a | b + a";
 | 
	
		
			
				|  |  | +function $UnknownVariableError(){return smalltalk.UnknownVariableError||(typeof UnknownVariableError=="undefined"?nil:UnknownVariableError)}
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  | +src="foo | a | b + a";
 | 
	
		
			
				|  |  |  ast=_st(smalltalk)._parse_(src);
 | 
	
		
			
				|  |  |  _st(self)._should_raise_((function(){
 | 
	
		
			
				|  |  | -return smalltalk.withContext(function($ctx2) {
return _st(self["@analyzer"])._visit_(ast);
 | 
	
		
			
				|  |  | -}, function($ctx2) {$ctx2.fillBlock({},$ctx1)})}),(smalltalk.UnknownVariableError || UnknownVariableError));
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx2) {
 | 
	
		
			
				|  |  | +return _st(self["@analyzer"])._visit_(ast);
 | 
	
		
			
				|  |  | +}, function($ctx2) {$ctx2.fillBlock({},$ctx1)})}),$UnknownVariableError());
 | 
	
		
			
				|  |  |  return self}, function($ctx1) {$ctx1.fill(self,"testUnknownVariables",{src:src,ast:ast},smalltalk.SemanticAnalyzerTest)})},
 | 
	
		
			
				|  |  |  messageSends: ["parse:", "should:raise:", "visit:"]}),
 | 
	
		
			
				|  |  |  smalltalk.SemanticAnalyzerTest);
 | 
	
	
		
			
				|  | @@ -912,11 +1051,14 @@ selector: "testUnknownVariablesWithScope",
 | 
	
		
			
				|  |  |  fn: function (){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  var src,ast;
 | 
	
		
			
				|  |  | -return smalltalk.withContext(function($ctx1) { 
src="foo | a b | [ c + 1. [ a + 1. d + 1 ]]";
 | 
	
		
			
				|  |  | +function $UnknownVariableError(){return smalltalk.UnknownVariableError||(typeof UnknownVariableError=="undefined"?nil:UnknownVariableError)}
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  | +src="foo | a b | [ c + 1. [ a + 1. d + 1 ]]";
 | 
	
		
			
				|  |  |  ast=_st(smalltalk)._parse_(src);
 | 
	
		
			
				|  |  |  _st(self)._should_raise_((function(){
 | 
	
		
			
				|  |  | -return smalltalk.withContext(function($ctx2) {
return _st(self["@analyzer"])._visit_(ast);
 | 
	
		
			
				|  |  | -}, function($ctx2) {$ctx2.fillBlock({},$ctx1)})}),(smalltalk.UnknownVariableError || UnknownVariableError));
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx2) {
 | 
	
		
			
				|  |  | +return _st(self["@analyzer"])._visit_(ast);
 | 
	
		
			
				|  |  | +}, function($ctx2) {$ctx2.fillBlock({},$ctx1)})}),$UnknownVariableError());
 | 
	
		
			
				|  |  |  return self}, function($ctx1) {$ctx1.fill(self,"testUnknownVariablesWithScope",{src:src,ast:ast},smalltalk.SemanticAnalyzerTest)})},
 | 
	
		
			
				|  |  |  messageSends: ["parse:", "should:raise:", "visit:"]}),
 | 
	
		
			
				|  |  |  smalltalk.SemanticAnalyzerTest);
 | 
	
	
		
			
				|  | @@ -928,7 +1070,8 @@ selector: "testVariableShadowing",
 | 
	
		
			
				|  |  |  fn: function (){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  var src,ast;
 | 
	
		
			
				|  |  | -return smalltalk.withContext(function($ctx1) { 
src="foo | a | a + 1";
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  | +src="foo | a | a + 1";
 | 
	
		
			
				|  |  |  ast=_st(smalltalk)._parse_(src);
 | 
	
		
			
				|  |  |  _st(self["@analyzer"])._visit_(ast);
 | 
	
		
			
				|  |  |  return self}, function($ctx1) {$ctx1.fill(self,"testVariableShadowing",{src:src,ast:ast},smalltalk.SemanticAnalyzerTest)})},
 | 
	
	
		
			
				|  | @@ -942,11 +1085,14 @@ selector: "testVariableShadowing2",
 | 
	
		
			
				|  |  |  fn: function (){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  var src,ast;
 | 
	
		
			
				|  |  | -return smalltalk.withContext(function($ctx1) { 
src="foo | a | a + 1. [ | a | a := 2 ]";
 | 
	
		
			
				|  |  | +function $ShadowingVariableError(){return smalltalk.ShadowingVariableError||(typeof ShadowingVariableError=="undefined"?nil:ShadowingVariableError)}
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  | +src="foo | a | a + 1. [ | a | a := 2 ]";
 | 
	
		
			
				|  |  |  ast=_st(smalltalk)._parse_(src);
 | 
	
		
			
				|  |  |  _st(self)._should_raise_((function(){
 | 
	
		
			
				|  |  | -return smalltalk.withContext(function($ctx2) {
return _st(self["@analyzer"])._visit_(ast);
 | 
	
		
			
				|  |  | -}, function($ctx2) {$ctx2.fillBlock({},$ctx1)})}),(smalltalk.ShadowingVariableError || ShadowingVariableError));
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx2) {
 | 
	
		
			
				|  |  | +return _st(self["@analyzer"])._visit_(ast);
 | 
	
		
			
				|  |  | +}, function($ctx2) {$ctx2.fillBlock({},$ctx1)})}),$ShadowingVariableError());
 | 
	
		
			
				|  |  |  return self}, function($ctx1) {$ctx1.fill(self,"testVariableShadowing2",{src:src,ast:ast},smalltalk.SemanticAnalyzerTest)})},
 | 
	
		
			
				|  |  |  messageSends: ["parse:", "should:raise:", "visit:"]}),
 | 
	
		
			
				|  |  |  smalltalk.SemanticAnalyzerTest);
 | 
	
	
		
			
				|  | @@ -958,7 +1104,8 @@ selector: "testVariableShadowing3",
 | 
	
		
			
				|  |  |  fn: function (){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  var src,ast;
 | 
	
		
			
				|  |  | -return smalltalk.withContext(function($ctx1) { 
src="foo | a | a + 1. [ | b | b := 2 ]";
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  | +src="foo | a | a + 1. [ | b | b := 2 ]";
 | 
	
		
			
				|  |  |  ast=_st(smalltalk)._parse_(src);
 | 
	
		
			
				|  |  |  _st(self["@analyzer"])._visit_(ast);
 | 
	
		
			
				|  |  |  return self}, function($ctx1) {$ctx1.fill(self,"testVariableShadowing3",{src:src,ast:ast},smalltalk.SemanticAnalyzerTest)})},
 | 
	
	
		
			
				|  | @@ -972,7 +1119,8 @@ selector: "testVariableShadowing4",
 | 
	
		
			
				|  |  |  fn: function (){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  var src,ast;
 | 
	
		
			
				|  |  | -return smalltalk.withContext(function($ctx1) { 
src="foo | a | a + 1. [ [ [ | b | b := 2 ] ] ]";
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  | +src="foo | a | a + 1. [ [ [ | b | b := 2 ] ] ]";
 | 
	
		
			
				|  |  |  ast=_st(smalltalk)._parse_(src);
 | 
	
		
			
				|  |  |  _st(self["@analyzer"])._visit_(ast);
 | 
	
		
			
				|  |  |  return self}, function($ctx1) {$ctx1.fill(self,"testVariableShadowing4",{src:src,ast:ast},smalltalk.SemanticAnalyzerTest)})},
 | 
	
	
		
			
				|  | @@ -986,11 +1134,14 @@ selector: "testVariableShadowing5",
 | 
	
		
			
				|  |  |  fn: function (){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  var src,ast;
 | 
	
		
			
				|  |  | -return smalltalk.withContext(function($ctx1) { 
src="foo | a | a + 1. [ [ [ | a | a := 2 ] ] ]";
 | 
	
		
			
				|  |  | +function $ShadowingVariableError(){return smalltalk.ShadowingVariableError||(typeof ShadowingVariableError=="undefined"?nil:ShadowingVariableError)}
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  | +src="foo | a | a + 1. [ [ [ | a | a := 2 ] ] ]";
 | 
	
		
			
				|  |  |  ast=_st(smalltalk)._parse_(src);
 | 
	
		
			
				|  |  |  _st(self)._should_raise_((function(){
 | 
	
		
			
				|  |  | -return smalltalk.withContext(function($ctx2) {
return _st(self["@analyzer"])._visit_(ast);
 | 
	
		
			
				|  |  | -}, function($ctx2) {$ctx2.fillBlock({},$ctx1)})}),(smalltalk.ShadowingVariableError || ShadowingVariableError));
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx2) {
 | 
	
		
			
				|  |  | +return _st(self["@analyzer"])._visit_(ast);
 | 
	
		
			
				|  |  | +}, function($ctx2) {$ctx2.fillBlock({},$ctx1)})}),$ShadowingVariableError());
 | 
	
		
			
				|  |  |  return self}, function($ctx1) {$ctx1.fill(self,"testVariableShadowing5",{src:src,ast:ast},smalltalk.SemanticAnalyzerTest)})},
 | 
	
		
			
				|  |  |  messageSends: ["parse:", "should:raise:", "visit:"]}),
 | 
	
		
			
				|  |  |  smalltalk.SemanticAnalyzerTest);
 | 
	
	
		
			
				|  | @@ -1002,7 +1153,8 @@ selector: "testVariablesLookup",
 | 
	
		
			
				|  |  |  fn: function (){
 | 
	
		
			
				|  |  |  var self=this;
 | 
	
		
			
				|  |  |  var src,ast;
 | 
	
		
			
				|  |  | -return smalltalk.withContext(function($ctx1) { 
src="foo | a | a + 1. [ | b | b := a ]";
 | 
	
		
			
				|  |  | +return smalltalk.withContext(function($ctx1) { 
 | 
	
		
			
				|  |  | +src="foo | a | a + 1. [ | b | b := a ]";
 | 
	
		
			
				|  |  |  ast=_st(smalltalk)._parse_(src);
 | 
	
		
			
				|  |  |  _st(self["@analyzer"])._visit_(ast);
 | 
	
		
			
				|  |  |  _st(self)._assert_(_st(_st(_st(_st(_st(_st(_st(ast)._nodes())._first())._nodes())._first())._receiver())._binding())._isTempVar());
 |