smalltalk.addPackage('Compiler-IR', {}); smalltalk.addClass('IRASTTranslator', smalltalk.NodeVisitor, ['source', 'theClass', 'method', 'sequence', 'nextAlias'], 'Compiler-IR'); smalltalk.IRASTTranslator.comment="I am the AST (abstract syntax tree) visitor responsible for building the intermediate representation graph.\x0aI rely on a builder object, instance of IRBuilder." smalltalk.addMethod( "_alias_", smalltalk.method({ selector: "alias:", category: 'visiting', fn: function (aNode){ var self=this; var variable; return smalltalk.withContext(function($ctx1) { var $1,$2,$3,$4,$5,$6,$7; $1=_st(aNode)._isImmutable(); if(smalltalk.assert($1)){ $2=_st(self)._visit_(aNode); return $2; }; $3=_st((smalltalk.IRVariable || IRVariable))._new(); _st($3)._variable_(_st(_st((smalltalk.AliasVar || AliasVar))._new())._name_(_st("$").__comma(_st(self)._nextAlias()))); $4=_st($3)._yourself(); variable=$4; $5=_st((smalltalk.IRAssignment || IRAssignment))._new(); _st($5)._add_(variable); _st($5)._add_(_st(self)._visit_(aNode)); $6=_st($5)._yourself(); _st(_st(self)._sequence())._add_($6); _st(_st(_st(self)._method())._internalVariables())._add_(variable); $7=variable; return $7; }, function($ctx1) {$ctx1.fill(self,"alias:",{aNode:aNode,variable:variable}, smalltalk.IRASTTranslator)})}, args: ["aNode"], source: "alias: aNode\x0a\x09| variable |\x0a\x0a\x09aNode isImmutable ifTrue: [ ^ self visit: aNode ].\x0a\x0a\x09variable := IRVariable new \x0a\x09\x09variable: (AliasVar new name: '$', self nextAlias); \x0a\x09\x09yourself.\x0a\x0a\x09self sequence add: (IRAssignment new\x0a\x09\x09add: variable;\x0a\x09\x09add: (self visit: aNode);\x0a\x09\x09yourself).\x0a\x0a\x09self method internalVariables add: variable.\x0a\x0a\x09^ variable", messageSends: ["ifTrue:", "visit:", "isImmutable", "variable:", "name:", ",", "nextAlias", "new", "yourself", "add:", "sequence", "internalVariables", "method"], referencedClasses: ["AliasVar", "IRVariable", "IRAssignment"] }), smalltalk.IRASTTranslator); smalltalk.addMethod( "_aliasTemporally_", smalltalk.method({ selector: "aliasTemporally:", category: 'visiting', fn: function (aCollection){ var self=this; var threshold,result; return smalltalk.withContext(function($ctx1) { var $1,$2,$4,$3,$5; threshold=(0); _st(aCollection)._withIndexDo_((function(each,i){ return smalltalk.withContext(function($ctx2) { $1=_st(each)._subtreeNeedsAliasing(); if(smalltalk.assert($1)){ threshold=i; return threshold; }; }, function($ctx2) {$ctx2.fillBlock({each:each,i:i},$ctx1)})})); result=_st((smalltalk.OrderedCollection || OrderedCollection))._new(); _st(aCollection)._withIndexDo_((function(each,i){ return smalltalk.withContext(function($ctx2) { $2=result; $4=_st(i).__lt_eq(threshold); if(smalltalk.assert($4)){ $3=_st(self)._alias_(each); } else { $3=_st(self)._visit_(each); }; return _st($2)._add_($3); }, function($ctx2) {$ctx2.fillBlock({each:each,i:i},$ctx1)})})); $5=result; return $5; }, function($ctx1) {$ctx1.fill(self,"aliasTemporally:",{aCollection:aCollection,threshold:threshold,result:result}, smalltalk.IRASTTranslator)})}, args: ["aCollection"], source: "aliasTemporally: aCollection\x0a\x09\x22https://github.com/NicolasPetton/amber/issues/296\x0a \x0a If a node is aliased, all preceding ones are aliased as well.\x0a The tree is iterated twice. First we get the aliasing dependency, \x0a then the aliasing itself is done\x22\x0a\x0a\x09| threshold result |\x0a threshold := 0.\x0a \x0a aCollection withIndexDo: [ :each :i |\x0a each subtreeNeedsAliasing\x0a\x09\x09 ifTrue: [ threshold := i ]].\x0a\x0a\x09result := OrderedCollection new.\x0a\x09aCollection withIndexDo: [ :each :i | \x0a\x09\x09result add: (i <= threshold\x0a\x09\x09\x09ifTrue: [ self alias: each ]\x0a\x09\x09\x09ifFalse: [ self visit: each ])].\x0a\x0a ^result", messageSends: ["withIndexDo:", "ifTrue:", "subtreeNeedsAliasing", "new", "add:", "ifTrue:ifFalse:", "alias:", "visit:", "<="], referencedClasses: ["OrderedCollection"] }), smalltalk.IRASTTranslator); smalltalk.addMethod( "_method", smalltalk.method({ selector: "method", category: 'accessing', fn: function (){ var self=this; return smalltalk.withContext(function($ctx1) { var $1; $1=self["@method"]; return $1; }, function($ctx1) {$ctx1.fill(self,"method",{}, smalltalk.IRASTTranslator)})}, args: [], source: "method\x0a\x09^ method", messageSends: [], referencedClasses: [] }), smalltalk.IRASTTranslator); smalltalk.addMethod( "_method_", smalltalk.method({ selector: "method:", category: 'accessing', fn: function (anIRMethod){ var self=this; return smalltalk.withContext(function($ctx1) { self["@method"]=anIRMethod; return self}, function($ctx1) {$ctx1.fill(self,"method:",{anIRMethod:anIRMethod}, smalltalk.IRASTTranslator)})}, args: ["anIRMethod"], source: "method: anIRMethod\x0a\x09method := anIRMethod", messageSends: [], referencedClasses: [] }), smalltalk.IRASTTranslator); smalltalk.addMethod( "_nextAlias", smalltalk.method({ selector: "nextAlias", category: 'accessing', fn: function (){ var self=this; return smalltalk.withContext(function($ctx1) { var $1,$2; $1=self["@nextAlias"]; if(($receiver = $1) == nil || $receiver == undefined){ self["@nextAlias"]=(0); self["@nextAlias"]; } else { $1; }; self["@nextAlias"]=_st(self["@nextAlias"]).__plus((1)); $2=_st(self["@nextAlias"])._asString(); return $2; }, function($ctx1) {$ctx1.fill(self,"nextAlias",{}, smalltalk.IRASTTranslator)})}, args: [], source: "nextAlias\x0a\x09nextAlias ifNil: [ nextAlias := 0 ].\x0a\x09nextAlias := nextAlias + 1.\x0a\x09^ nextAlias asString", messageSends: ["ifNil:", "+", "asString"], referencedClasses: [] }), smalltalk.IRASTTranslator); smalltalk.addMethod( "_sequence", smalltalk.method({ selector: "sequence", category: 'accessing', fn: function (){ var self=this; return smalltalk.withContext(function($ctx1) { var $1; $1=self["@sequence"]; return $1; }, function($ctx1) {$ctx1.fill(self,"sequence",{}, smalltalk.IRASTTranslator)})}, args: [], source: "sequence\x0a\x09^ sequence", messageSends: [], referencedClasses: [] }), smalltalk.IRASTTranslator); smalltalk.addMethod( "_sequence_", smalltalk.method({ selector: "sequence:", category: 'accessing', fn: function (anIRSequence){ var self=this; return smalltalk.withContext(function($ctx1) { self["@sequence"]=anIRSequence; return self}, function($ctx1) {$ctx1.fill(self,"sequence:",{anIRSequence:anIRSequence}, smalltalk.IRASTTranslator)})}, args: ["anIRSequence"], source: "sequence: anIRSequence\x0a\x09sequence := anIRSequence", messageSends: [], referencedClasses: [] }), smalltalk.IRASTTranslator); smalltalk.addMethod( "_source", smalltalk.method({ selector: "source", category: 'accessing', fn: function (){ var self=this; return smalltalk.withContext(function($ctx1) { var $1; $1=self["@source"]; return $1; }, function($ctx1) {$ctx1.fill(self,"source",{}, smalltalk.IRASTTranslator)})}, args: [], source: "source\x0a\x09^ source", messageSends: [], referencedClasses: [] }), smalltalk.IRASTTranslator); smalltalk.addMethod( "_source_", smalltalk.method({ selector: "source:", category: 'accessing', fn: function (aString){ var self=this; return smalltalk.withContext(function($ctx1) { self["@source"]=aString; return self}, function($ctx1) {$ctx1.fill(self,"source:",{aString:aString}, smalltalk.IRASTTranslator)})}, args: ["aString"], source: "source: aString\x0a\x09source := aString", messageSends: [], referencedClasses: [] }), smalltalk.IRASTTranslator); smalltalk.addMethod( "_theClass", smalltalk.method({ selector: "theClass", category: 'accessing', fn: function (){ var self=this; return smalltalk.withContext(function($ctx1) { var $1; $1=self["@theClass"]; return $1; }, function($ctx1) {$ctx1.fill(self,"theClass",{}, smalltalk.IRASTTranslator)})}, args: [], source: "theClass\x0a\x09^ theClass", messageSends: [], referencedClasses: [] }), smalltalk.IRASTTranslator); smalltalk.addMethod( "_theClass_", smalltalk.method({ selector: "theClass:", category: 'accessing', fn: function (aClass){ var self=this; return smalltalk.withContext(function($ctx1) { self["@theClass"]=aClass; return self}, function($ctx1) {$ctx1.fill(self,"theClass:",{aClass:aClass}, smalltalk.IRASTTranslator)})}, args: ["aClass"], source: "theClass: aClass\x0a\x09theClass := aClass", messageSends: [], referencedClasses: [] }), smalltalk.IRASTTranslator); smalltalk.addMethod( "_visitAssignmentNode_", smalltalk.method({ selector: "visitAssignmentNode:", category: 'visiting', fn: function (aNode){ var self=this; var left,right,assignment; return smalltalk.withContext(function($ctx1) { var $1,$2,$3; right=_st(self)._visit_(_st(aNode)._right()); left=_st(self)._visit_(_st(aNode)._left()); $1=_st((smalltalk.IRAssignment || IRAssignment))._new(); _st($1)._add_(left); _st($1)._add_(right); $2=_st($1)._yourself(); _st(_st(self)._sequence())._add_($2); $3=left; return $3; }, function($ctx1) {$ctx1.fill(self,"visitAssignmentNode:",{aNode:aNode,left:left,right:right,assignment:assignment}, smalltalk.IRASTTranslator)})}, args: ["aNode"], source: "visitAssignmentNode: aNode\x0a\x09| left right assignment |\x0a\x09right := self visit: aNode right.\x0a\x09left := self visit: aNode left.\x0a\x09self sequence add: (IRAssignment new \x0a\x09\x09add: left;\x0a\x09\x09add: right;\x0a\x09\x09yourself).\x0a\x09^ left", messageSends: ["visit:", "right", "left", "add:", "new", "yourself", "sequence"], referencedClasses: ["IRAssignment"] }), smalltalk.IRASTTranslator); smalltalk.addMethod( "_visitBlockNode_", smalltalk.method({ selector: "visitBlockNode:", category: 'visiting', fn: function (aNode){ var self=this; var closure; return smalltalk.withContext(function($ctx1) { var $1,$2,$3,$4,$5; $1=_st((smalltalk.IRClosure || IRClosure))._new(); _st($1)._arguments_(_st(aNode)._parameters()); _st($1)._scope_(_st(aNode)._scope()); $2=_st($1)._yourself(); closure=$2; _st(_st(_st(aNode)._scope())._temps())._do_((function(each){ return smalltalk.withContext(function($ctx2) { $3=_st((smalltalk.IRTempDeclaration || IRTempDeclaration))._new(); _st($3)._name_(_st(each)._name()); _st($3)._scope_(_st(aNode)._scope()); $4=_st($3)._yourself(); return _st(closure)._add_($4); }, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1)})})); _st(_st(aNode)._nodes())._do_((function(each){ return smalltalk.withContext(function($ctx2) { return _st(closure)._add_(_st(self)._visit_(each)); }, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1)})})); $5=closure; return $5; }, function($ctx1) {$ctx1.fill(self,"visitBlockNode:",{aNode:aNode,closure:closure}, smalltalk.IRASTTranslator)})}, args: ["aNode"], source: "visitBlockNode: aNode\x0a\x09| closure |\x0a\x09closure := IRClosure new\x0a\x09\x09arguments: aNode parameters;\x0a\x09\x09scope: aNode scope;\x0a\x09\x09yourself.\x0a\x09aNode scope temps do: [ :each |\x0a\x09\x09closure add: (IRTempDeclaration new \x0a\x09\x09\x09name: each name;\x0a scope: aNode scope;\x0a\x09\x09\x09yourself) ].\x0a\x09aNode nodes do: [ :each | closure add: (self visit: each) ].\x0a\x09^ closure", messageSends: ["arguments:", "parameters", "new", "scope:", "scope", "yourself", "do:", "add:", "name:", "name", "temps", "visit:", "nodes"], referencedClasses: ["IRClosure", "IRTempDeclaration"] }), smalltalk.IRASTTranslator); smalltalk.addMethod( "_visitBlockSequenceNode_", smalltalk.method({ selector: "visitBlockSequenceNode:", category: 'visiting', fn: function (aNode){ var self=this; return smalltalk.withContext(function($ctx1) { var $2,$3,$4,$1; $1=_st(self)._withSequence_do_(_st((smalltalk.IRBlockSequence || IRBlockSequence))._new(),(function(){ return smalltalk.withContext(function($ctx2) { return _st(_st(aNode)._nodes())._ifNotEmpty_((function(){ return smalltalk.withContext(function($ctx3) { _st(_st(_st(aNode)._nodes())._allButLast())._do_((function(each){ return smalltalk.withContext(function($ctx4) { return _st(_st(self)._sequence())._add_(_st(self)._visit_(each)); }, function($ctx4) {$ctx4.fillBlock({each:each},$ctx1)})})); $2=_st(_st(_st(aNode)._nodes())._last())._isReturnNode(); if(smalltalk.assert($2)){ return _st(_st(self)._sequence())._add_(_st(self)._visit_(_st(_st(aNode)._nodes())._last())); } else { $3=_st((smalltalk.IRBlockReturn || IRBlockReturn))._new(); _st($3)._add_(_st(self)._visit_(_st(_st(aNode)._nodes())._last())); $4=_st($3)._yourself(); return _st(_st(self)._sequence())._add_($4); }; }, function($ctx3) {$ctx3.fillBlock({},$ctx1)})})); }, function($ctx2) {$ctx2.fillBlock({},$ctx1)})})); return $1; }, function($ctx1) {$ctx1.fill(self,"visitBlockSequenceNode:",{aNode:aNode}, smalltalk.IRASTTranslator)})}, args: ["aNode"], source: "visitBlockSequenceNode: aNode\x0a\x09^ self\x0a\x09\x09withSequence: IRBlockSequence new\x0a\x09\x09do: [ \x0a\x09\x09\x09aNode nodes ifNotEmpty: [\x0a\x09\x09\x09\x09aNode nodes allButLast do: [ :each | \x0a\x09\x09\x09\x09\x09self sequence add: (self visit: each) ].\x0a\x09\x09\x09\x09aNode nodes last isReturnNode \x0a\x09\x09\x09\x09\x09ifFalse: [ self sequence add: (IRBlockReturn new add: (self visit: aNode nodes last); yourself) ]\x0a\x09\x09\x09\x09\x09ifTrue: [ self sequence add: (self visit: aNode nodes last) ]]]", messageSends: ["withSequence:do:", "new", "ifNotEmpty:", "do:", "add:", "visit:", "sequence", "allButLast", "nodes", "ifFalse:ifTrue:", "last", "yourself", "isReturnNode"], referencedClasses: ["IRBlockSequence", "IRBlockReturn"] }), smalltalk.IRASTTranslator); smalltalk.addMethod( "_visitCascadeNode_", smalltalk.method({ selector: "visitCascadeNode:", category: 'visiting', fn: function (aNode){ var self=this; var alias; return smalltalk.withContext(function($ctx1) { var $1,$2; $1=_st(_st(aNode)._receiver())._isImmutable(); if(! smalltalk.assert($1)){ alias=_st(self)._alias_(_st(aNode)._receiver()); alias; _st(_st(aNode)._nodes())._do_((function(each){ return smalltalk.withContext(function($ctx2) { return _st(each)._receiver_(_st(_st((smalltalk.VariableNode || VariableNode))._new())._binding_(_st(alias)._variable())); }, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1)})})); }; _st(_st(_st(aNode)._nodes())._allButLast())._do_((function(each){ return smalltalk.withContext(function($ctx2) { return _st(_st(self)._sequence())._add_(_st(self)._visit_(each)); }, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1)})})); $2=_st(self)._alias_(_st(_st(aNode)._nodes())._last()); return $2; }, function($ctx1) {$ctx1.fill(self,"visitCascadeNode:",{aNode:aNode,alias:alias}, smalltalk.IRASTTranslator)})}, args: ["aNode"], source: "visitCascadeNode: aNode\x0a\x09| alias |\x0a\x0a\x09aNode receiver isImmutable ifFalse: [ \x0a\x09\x09alias := self alias: aNode receiver.\x0a\x09\x09aNode nodes do: [ :each |\x0a\x09\x09\x09each receiver: (VariableNode new binding: alias variable) ]].\x0a\x0a\x09aNode nodes allButLast do: [ :each |\x0a\x09\x09self sequence add: (self visit: each) ].\x0a\x0a\x09^ self alias: aNode nodes last", messageSends: ["ifFalse:", "alias:", "receiver", "do:", "receiver:", "binding:", "variable", "new", "nodes", "isImmutable", "add:", "visit:", "sequence", "allButLast", "last"], referencedClasses: ["VariableNode"] }), smalltalk.IRASTTranslator); smalltalk.addMethod( "_visitDynamicArrayNode_", smalltalk.method({ selector: "visitDynamicArrayNode:", category: 'visiting', fn: function (aNode){ var self=this; var array; return smalltalk.withContext(function($ctx1) { var $1; array=_st((smalltalk.IRDynamicArray || IRDynamicArray))._new(); _st(_st(self)._aliasTemporally_(_st(aNode)._nodes()))._do_((function(each){ return smalltalk.withContext(function($ctx2) { return _st(array)._add_(each); }, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1)})})); $1=array; return $1; }, function($ctx1) {$ctx1.fill(self,"visitDynamicArrayNode:",{aNode:aNode,array:array}, smalltalk.IRASTTranslator)})}, args: ["aNode"], source: "visitDynamicArrayNode: aNode\x0a\x09| array |\x0a\x09array := IRDynamicArray new.\x0a\x09(self aliasTemporally: aNode nodes) do: [:each | array add: each].\x0a\x09^ array", messageSends: ["new", "do:", "add:", "aliasTemporally:", "nodes"], referencedClasses: ["IRDynamicArray"] }), smalltalk.IRASTTranslator); smalltalk.addMethod( "_visitDynamicDictionaryNode_", smalltalk.method({ selector: "visitDynamicDictionaryNode:", category: 'visiting', fn: function (aNode){ var self=this; var dictionary; return smalltalk.withContext(function($ctx1) { var $1; dictionary=_st((smalltalk.IRDynamicDictionary || IRDynamicDictionary))._new(); _st(_st(self)._aliasTemporally_(_st(aNode)._nodes()))._do_((function(each){ return smalltalk.withContext(function($ctx2) { return _st(dictionary)._add_(each); }, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1)})})); $1=dictionary; return $1; }, function($ctx1) {$ctx1.fill(self,"visitDynamicDictionaryNode:",{aNode:aNode,dictionary:dictionary}, smalltalk.IRASTTranslator)})}, args: ["aNode"], source: "visitDynamicDictionaryNode: aNode\x0a\x09| dictionary |\x0a\x09dictionary := IRDynamicDictionary new.\x0a (self aliasTemporally: aNode nodes) do: [:each | dictionary add: each].\x0a\x09^ dictionary", messageSends: ["new", "do:", "add:", "aliasTemporally:", "nodes"], referencedClasses: ["IRDynamicDictionary"] }), smalltalk.IRASTTranslator); smalltalk.addMethod( "_visitJSStatementNode_", smalltalk.method({ selector: "visitJSStatementNode:", category: 'visiting', fn: function (aNode){ var self=this; return smalltalk.withContext(function($ctx1) { var $2,$3,$1; $2=_st((smalltalk.IRVerbatim || IRVerbatim))._new(); _st($2)._source_(_st(aNode)._source()); $3=_st($2)._yourself(); $1=$3; return $1; }, function($ctx1) {$ctx1.fill(self,"visitJSStatementNode:",{aNode:aNode}, smalltalk.IRASTTranslator)})}, args: ["aNode"], source: "visitJSStatementNode: aNode\x0a\x09^ IRVerbatim new\x0a\x09\x09source: aNode source;\x0a\x09\x09yourself", messageSends: ["source:", "source", "new", "yourself"], referencedClasses: ["IRVerbatim"] }), smalltalk.IRASTTranslator); smalltalk.addMethod( "_visitMethodNode_", smalltalk.method({ selector: "visitMethodNode:", category: 'visiting', fn: function (aNode){ var self=this; return smalltalk.withContext(function($ctx1) { var $1,$2,$3,$4,$5,$6,$7,$8; $1=_st((smalltalk.IRMethod || IRMethod))._new(); _st($1)._source_(_st(self)._source()); _st($1)._theClass_(_st(self)._theClass()); _st($1)._arguments_(_st(aNode)._arguments()); _st($1)._selector_(_st(aNode)._selector()); _st($1)._messageSends_(_st(aNode)._messageSends()); _st($1)._superSends_(_st(aNode)._superSends()); _st($1)._classReferences_(_st(aNode)._classReferences()); _st($1)._scope_(_st(aNode)._scope()); $2=_st($1)._yourself(); _st(self)._method_($2); _st(_st(_st(aNode)._scope())._temps())._do_((function(each){ return smalltalk.withContext(function($ctx2) { $3=_st((smalltalk.IRTempDeclaration || IRTempDeclaration))._new(); _st($3)._name_(_st(each)._name()); _st($3)._scope_(_st(aNode)._scope()); $4=_st($3)._yourself(); return _st(_st(self)._method())._add_($4); }, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1)})})); _st(_st(aNode)._nodes())._do_((function(each){ return smalltalk.withContext(function($ctx2) { return _st(_st(self)._method())._add_(_st(self)._visit_(each)); }, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1)})})); $5=_st(_st(aNode)._scope())._hasLocalReturn(); if(! smalltalk.assert($5)){ $6=_st((smalltalk.IRVariable || IRVariable))._new(); _st($6)._variable_(_st(_st(_st(aNode)._scope())._pseudoVars())._at_("self")); $7=_st($6)._yourself(); _st(_st(_st(self)._method())._add_(_st((smalltalk.IRReturn || IRReturn))._new()))._add_($7); }; $8=_st(self)._method(); return $8; }, function($ctx1) {$ctx1.fill(self,"visitMethodNode:",{aNode:aNode}, smalltalk.IRASTTranslator)})}, args: ["aNode"], source: "visitMethodNode: aNode\x0a\x0a\x09self method: (IRMethod new\x0a\x09\x09source: self source;\x0a theClass: self theClass;\x0a\x09\x09arguments: aNode arguments;\x0a\x09\x09selector: aNode selector;\x0a\x09\x09messageSends: aNode messageSends;\x0a superSends: aNode superSends;\x0a\x09\x09classReferences: aNode classReferences;\x0a\x09\x09scope: aNode scope;\x0a\x09\x09yourself).\x0a\x0a\x09aNode scope temps do: [ :each |\x0a\x09\x09self method add: (IRTempDeclaration new\x0a\x09\x09\x09name: each name;\x0a scope: aNode scope;\x0a\x09\x09\x09yourself) ].\x0a\x0a\x09aNode nodes do: [ :each | self method add: (self visit: each) ].\x0a\x0a\x09aNode scope hasLocalReturn ifFalse: [\x0a\x09\x09(self method add: IRReturn new) add: (IRVariable new\x0a\x09\x09\x09variable: (aNode scope pseudoVars at: 'self');\x0a\x09\x09\x09yourself) ].\x0a\x0a\x09^ self method", messageSends: ["method:", "source:", "source", "new", "theClass:", "theClass", "arguments:", "arguments", "selector:", "selector", "messageSends:", "messageSends", "superSends:", "superSends", "classReferences:", "classReferences", "scope:", "scope", "yourself", "do:", "add:", "name:", "name", "method", "temps", "visit:", "nodes", "ifFalse:", "variable:", "at:", "pseudoVars", "hasLocalReturn"], referencedClasses: ["IRMethod", "IRTempDeclaration", "IRVariable", "IRReturn"] }), smalltalk.IRASTTranslator); smalltalk.addMethod( "_visitReturnNode_", smalltalk.method({ selector: "visitReturnNode:", category: 'visiting', fn: function (aNode){ var self=this; var return_; return smalltalk.withContext(function($ctx1) { var $1,$2; $1=_st(aNode)._nonLocalReturn(); if(smalltalk.assert($1)){ return_=_st((smalltalk.IRNonLocalReturn || IRNonLocalReturn))._new(); } else { return_=_st((smalltalk.IRReturn || IRReturn))._new(); }; _st(return_)._scope_(_st(aNode)._scope()); _st(_st(aNode)._nodes())._do_((function(each){ return smalltalk.withContext(function($ctx2) { return _st(return_)._add_(_st(self)._alias_(each)); }, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1)})})); $2=return_; return $2; }, function($ctx1) {$ctx1.fill(self,"visitReturnNode:",{aNode:aNode,return_:return_}, smalltalk.IRASTTranslator)})}, args: ["aNode"], source: "visitReturnNode: aNode\x0a\x09| return |\x0a\x09return := aNode nonLocalReturn \x0a\x09\x09ifTrue: [ IRNonLocalReturn new ]\x0a\x09\x09ifFalse: [ IRReturn new ].\x0a\x09return scope: aNode scope.\x0a\x09aNode nodes do: [ :each |\x0a\x09\x09return add: (self alias: each) ].\x0a\x09^ return", messageSends: ["ifTrue:ifFalse:", "new", "nonLocalReturn", "scope:", "scope", "do:", "add:", "alias:", "nodes"], referencedClasses: ["IRNonLocalReturn", "IRReturn"] }), smalltalk.IRASTTranslator); smalltalk.addMethod( "_visitSendNode_", smalltalk.method({ selector: "visitSendNode:", category: 'visiting', fn: function (aNode){ var self=this; var send,all,receiver,arguments; return smalltalk.withContext(function($ctx1) { var $1,$2,$3,$4; send=_st((smalltalk.IRSend || IRSend))._new(); $1=send; _st($1)._selector_(_st(aNode)._selector()); $2=_st($1)._index_(_st(aNode)._index()); $3=_st(aNode)._superSend(); if(smalltalk.assert($3)){ _st(send)._classSend_(_st(_st(self)._theClass())._superclass()); }; all=_st(self)._aliasTemporally_(_st([_st(aNode)._receiver()]).__comma(_st(aNode)._arguments())); receiver=_st(all)._first(); arguments=_st(all)._allButFirst(); _st(send)._add_(receiver); _st(arguments)._do_((function(each){ return smalltalk.withContext(function($ctx2) { return _st(send)._add_(each); }, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1)})})); $4=send; return $4; }, function($ctx1) {$ctx1.fill(self,"visitSendNode:",{aNode:aNode,send:send,all:all,receiver:receiver,arguments:arguments}, smalltalk.IRASTTranslator)})}, args: ["aNode"], source: "visitSendNode: aNode\x0a\x09| send all receiver arguments |\x0a\x09send := IRSend new.\x0a\x09send \x0a\x09\x09selector: aNode selector;\x0a\x09\x09index: aNode index.\x0a\x09aNode superSend ifTrue: [ send classSend: self theClass superclass ].\x0a \x0a all := self aliasTemporally: { aNode receiver }, aNode arguments.\x0a\x09receiver := all first.\x0a\x09arguments := all allButFirst.\x0a\x0a\x09send add: receiver.\x0a\x09arguments do: [ :each | send add: each ].\x0a\x0a\x09^ send", messageSends: ["new", "selector:", "selector", "index:", "index", "ifTrue:", "classSend:", "superclass", "theClass", "superSend", "aliasTemporally:", ",", "arguments", "receiver", "first", "allButFirst", "add:", "do:"], referencedClasses: ["IRSend"] }), smalltalk.IRASTTranslator); smalltalk.addMethod( "_visitSequenceNode_", smalltalk.method({ selector: "visitSequenceNode:", category: 'visiting', fn: function (aNode){ var self=this; return smalltalk.withContext(function($ctx1) { var $2,$1; $1=_st(self)._withSequence_do_(_st((smalltalk.IRSequence || IRSequence))._new(),(function(){ return smalltalk.withContext(function($ctx2) { return _st(_st(aNode)._nodes())._do_((function(each){ var instruction; return smalltalk.withContext(function($ctx3) { instruction=_st(self)._visit_(each); instruction; $2=_st(instruction)._isVariable(); if(! smalltalk.assert($2)){ return _st(_st(self)._sequence())._add_(instruction); }; }, function($ctx3) {$ctx3.fillBlock({each:each,instruction:instruction},$ctx1)})})); }, function($ctx2) {$ctx2.fillBlock({},$ctx1)})})); return $1; }, function($ctx1) {$ctx1.fill(self,"visitSequenceNode:",{aNode:aNode}, smalltalk.IRASTTranslator)})}, args: ["aNode"], source: "visitSequenceNode: aNode\x0a\x09^ self \x0a\x09\x09withSequence: IRSequence new \x09\x0a\x09\x09do: [\x0a\x09\x09\x09aNode nodes do: [ :each | | instruction |\x0a\x09\x09\x09\x09instruction := self visit: each.\x0a\x09\x09\x09\x09instruction isVariable ifFalse: [\x0a\x09\x09\x09\x09\x09self sequence add: instruction ]]]", messageSends: ["withSequence:do:", "new", "do:", "visit:", "ifFalse:", "add:", "sequence", "isVariable", "nodes"], referencedClasses: ["IRSequence"] }), smalltalk.IRASTTranslator); smalltalk.addMethod( "_visitValueNode_", smalltalk.method({ selector: "visitValueNode:", category: 'visiting', fn: function (aNode){ var self=this; return smalltalk.withContext(function($ctx1) { var $2,$3,$1; $2=_st((smalltalk.IRValue || IRValue))._new(); _st($2)._value_(_st(aNode)._value()); $3=_st($2)._yourself(); $1=$3; return $1; }, function($ctx1) {$ctx1.fill(self,"visitValueNode:",{aNode:aNode}, smalltalk.IRASTTranslator)})}, args: ["aNode"], source: "visitValueNode: aNode\x0a\x09^ IRValue new \x0a\x09\x09value: aNode value; \x0a\x09\x09yourself", messageSends: ["value:", "value", "new", "yourself"], referencedClasses: ["IRValue"] }), smalltalk.IRASTTranslator); smalltalk.addMethod( "_visitVariableNode_", smalltalk.method({ selector: "visitVariableNode:", category: 'visiting', fn: function (aNode){ var self=this; return smalltalk.withContext(function($ctx1) { var $2,$3,$1; $2=_st((smalltalk.IRVariable || IRVariable))._new(); _st($2)._variable_(_st(aNode)._binding()); $3=_st($2)._yourself(); $1=$3; return $1; }, function($ctx1) {$ctx1.fill(self,"visitVariableNode:",{aNode:aNode}, smalltalk.IRASTTranslator)})}, args: ["aNode"], source: "visitVariableNode: aNode\x0a\x09^ IRVariable new \x0a\x09\x09variable: aNode binding; \x0a\x09\x09yourself", messageSends: ["variable:", "binding", "new", "yourself"], referencedClasses: ["IRVariable"] }), smalltalk.IRASTTranslator); smalltalk.addMethod( "_withSequence_do_", smalltalk.method({ selector: "withSequence:do:", category: 'accessing', fn: function (aSequence,aBlock){ var self=this; var outerSequence; return smalltalk.withContext(function($ctx1) { var $1; outerSequence=_st(self)._sequence(); _st(self)._sequence_(aSequence); _st(aBlock)._value(); _st(self)._sequence_(outerSequence); $1=aSequence; return $1; }, function($ctx1) {$ctx1.fill(self,"withSequence:do:",{aSequence:aSequence,aBlock:aBlock,outerSequence:outerSequence}, smalltalk.IRASTTranslator)})}, args: ["aSequence", "aBlock"], source: "withSequence: aSequence do: aBlock\x0a\x09| outerSequence |\x0a\x09outerSequence := self sequence.\x0a\x09self sequence: aSequence.\x0a\x09aBlock value.\x0a\x09self sequence: outerSequence.\x0a\x09^ aSequence", messageSends: ["sequence", "sequence:", "value"], referencedClasses: [] }), smalltalk.IRASTTranslator); smalltalk.addClass('IRInstruction', smalltalk.Object, ['parent', 'instructions'], 'Compiler-IR'); smalltalk.IRInstruction.comment="I am the abstract root class of the IR (intermediate representation) instructions class hierarchy.\x0aThe IR graph is used to emit JavaScript code using a JSStream." smalltalk.addMethod( "_accept_", smalltalk.method({ selector: "accept:", category: 'visiting', fn: function (aVisitor){ var self=this; return smalltalk.withContext(function($ctx1) { var $1; $1=_st(aVisitor)._visitIRInstruction_(self); return $1; }, function($ctx1) {$ctx1.fill(self,"accept:",{aVisitor:aVisitor}, smalltalk.IRInstruction)})}, args: ["aVisitor"], source: "accept: aVisitor\x0a\x09^ aVisitor visitIRInstruction: self", messageSends: ["visitIRInstruction:"], referencedClasses: [] }), smalltalk.IRInstruction); smalltalk.addMethod( "_add_", smalltalk.method({ selector: "add:", category: 'building', fn: function (anObject){ var self=this; return smalltalk.withContext(function($ctx1) { var $1; _st(anObject)._parent_(self); $1=_st(_st(self)._instructions())._add_(anObject); return $1; }, function($ctx1) {$ctx1.fill(self,"add:",{anObject:anObject}, smalltalk.IRInstruction)})}, args: ["anObject"], source: "add: anObject\x0a\x09anObject parent: self.\x0a\x09^ self instructions add: anObject", messageSends: ["parent:", "add:", "instructions"], referencedClasses: [] }), smalltalk.IRInstruction); smalltalk.addMethod( "_canBeAssigned", smalltalk.method({ selector: "canBeAssigned", category: 'testing', fn: function (){ var self=this; return smalltalk.withContext(function($ctx1) { return true; }, function($ctx1) {$ctx1.fill(self,"canBeAssigned",{}, smalltalk.IRInstruction)})}, args: [], source: "canBeAssigned\x0a\x09^ true", messageSends: [], referencedClasses: [] }), smalltalk.IRInstruction); smalltalk.addMethod( "_instructions", smalltalk.method({ selector: "instructions", category: 'accessing', fn: function (){ var self=this; return smalltalk.withContext(function($ctx1) { var $2,$1; $2=self["@instructions"]; if(($receiver = $2) == nil || $receiver == undefined){ self["@instructions"]=_st((smalltalk.OrderedCollection || OrderedCollection))._new(); $1=self["@instructions"]; } else { $1=$2; }; return $1; }, function($ctx1) {$ctx1.fill(self,"instructions",{}, smalltalk.IRInstruction)})}, args: [], source: "instructions\x0a\x09^ instructions ifNil: [ instructions := OrderedCollection new ]", messageSends: ["ifNil:", "new"], referencedClasses: ["OrderedCollection"] }), smalltalk.IRInstruction); smalltalk.addMethod( "_isClosure", smalltalk.method({ selector: "isClosure", category: 'testing', fn: function (){ var self=this; return smalltalk.withContext(function($ctx1) { return false; }, function($ctx1) {$ctx1.fill(self,"isClosure",{}, smalltalk.IRInstruction)})}, args: [], source: "isClosure\x0a\x09^ false", messageSends: [], referencedClasses: [] }), smalltalk.IRInstruction); smalltalk.addMethod( "_isInlined", smalltalk.method({ selector: "isInlined", category: 'testing', fn: function (){ var self=this; return smalltalk.withContext(function($ctx1) { return false; }, function($ctx1) {$ctx1.fill(self,"isInlined",{}, smalltalk.IRInstruction)})}, args: [], source: "isInlined\x0a\x09^ false", messageSends: [], referencedClasses: [] }), smalltalk.IRInstruction); smalltalk.addMethod( "_isLocalReturn", smalltalk.method({ selector: "isLocalReturn", category: 'testing', fn: function (){ var self=this; return smalltalk.withContext(function($ctx1) { return false; }, function($ctx1) {$ctx1.fill(self,"isLocalReturn",{}, smalltalk.IRInstruction)})}, args: [], source: "isLocalReturn\x0a\x09^ false", messageSends: [], referencedClasses: [] }), smalltalk.IRInstruction); smalltalk.addMethod( "_isMethod", smalltalk.method({ selector: "isMethod", category: 'testing', fn: function (){ var self=this; return smalltalk.withContext(function($ctx1) { return false; }, function($ctx1) {$ctx1.fill(self,"isMethod",{}, smalltalk.IRInstruction)})}, args: [], source: "isMethod\x0a\x09^ false", messageSends: [], referencedClasses: [] }), smalltalk.IRInstruction); smalltalk.addMethod( "_isReturn", smalltalk.method({ selector: "isReturn", category: 'testing', fn: function (){ var self=this; return smalltalk.withContext(function($ctx1) { return false; }, function($ctx1) {$ctx1.fill(self,"isReturn",{}, smalltalk.IRInstruction)})}, args: [], source: "isReturn\x0a\x09^ false", messageSends: [], referencedClasses: [] }), smalltalk.IRInstruction); smalltalk.addMethod( "_isSend", smalltalk.method({ selector: "isSend", category: 'testing', fn: function (){ var self=this; return smalltalk.withContext(function($ctx1) { return false; }, function($ctx1) {$ctx1.fill(self,"isSend",{}, smalltalk.IRInstruction)})}, args: [], source: "isSend\x0a\x09^ false", messageSends: [], referencedClasses: [] }), smalltalk.IRInstruction); smalltalk.addMethod( "_isSequence", smalltalk.method({ selector: "isSequence", category: 'testing', fn: function (){ var self=this; return smalltalk.withContext(function($ctx1) { return false; }, function($ctx1) {$ctx1.fill(self,"isSequence",{}, smalltalk.IRInstruction)})}, args: [], source: "isSequence\x0a\x09^ false", messageSends: [], referencedClasses: [] }), smalltalk.IRInstruction); smalltalk.addMethod( "_isTempDeclaration", smalltalk.method({ selector: "isTempDeclaration", category: 'testing', fn: function (){ var self=this; return smalltalk.withContext(function($ctx1) { return false; }, function($ctx1) {$ctx1.fill(self,"isTempDeclaration",{}, smalltalk.IRInstruction)})}, args: [], source: "isTempDeclaration\x0a\x09^ false", messageSends: [], referencedClasses: [] }), smalltalk.IRInstruction); smalltalk.addMethod( "_isVariable", smalltalk.method({ selector: "isVariable", category: 'testing', fn: function (){ var self=this; return smalltalk.withContext(function($ctx1) { return false; }, function($ctx1) {$ctx1.fill(self,"isVariable",{}, smalltalk.IRInstruction)})}, args: [], source: "isVariable\x0a\x09^ false", messageSends: [], referencedClasses: [] }), smalltalk.IRInstruction); smalltalk.addMethod( "_method", smalltalk.method({ selector: "method", category: 'accessing', fn: function (){ var self=this; return smalltalk.withContext(function($ctx1) { var $1; $1=_st(_st(self)._parent())._method(); return $1; }, function($ctx1) {$ctx1.fill(self,"method",{}, smalltalk.IRInstruction)})}, args: [], source: "method\x0a\x09^ self parent method", messageSends: ["method", "parent"], referencedClasses: [] }), smalltalk.IRInstruction); smalltalk.addMethod( "_parent", smalltalk.method({ selector: "parent", category: 'accessing', fn: function (){ var self=this; return smalltalk.withContext(function($ctx1) { var $1; $1=self["@parent"]; return $1; }, function($ctx1) {$ctx1.fill(self,"parent",{}, smalltalk.IRInstruction)})}, args: [], source: "parent\x0a\x09^ parent", messageSends: [], referencedClasses: [] }), smalltalk.IRInstruction); smalltalk.addMethod( "_parent_", smalltalk.method({ selector: "parent:", category: 'accessing', fn: function (anIRInstruction){ var self=this; return smalltalk.withContext(function($ctx1) { self["@parent"]=anIRInstruction; return self}, function($ctx1) {$ctx1.fill(self,"parent:",{anIRInstruction:anIRInstruction}, smalltalk.IRInstruction)})}, args: ["anIRInstruction"], source: "parent: anIRInstruction\x0a\x09parent := anIRInstruction", messageSends: [], referencedClasses: [] }), smalltalk.IRInstruction); smalltalk.addMethod( "_remove", smalltalk.method({ selector: "remove", category: 'building', fn: function (){ var self=this; return smalltalk.withContext(function($ctx1) { _st(_st(self)._parent())._remove_(self); return self}, function($ctx1) {$ctx1.fill(self,"remove",{}, smalltalk.IRInstruction)})}, args: [], source: "remove\x0a\x09self parent remove: self", messageSends: ["remove:", "parent"], referencedClasses: [] }), smalltalk.IRInstruction); smalltalk.addMethod( "_remove_", smalltalk.method({ selector: "remove:", category: 'building', fn: function (anIRInstruction){ var self=this; return smalltalk.withContext(function($ctx1) { _st(_st(self)._instructions())._remove_(anIRInstruction); return self}, function($ctx1) {$ctx1.fill(self,"remove:",{anIRInstruction:anIRInstruction}, smalltalk.IRInstruction)})}, args: ["anIRInstruction"], source: "remove: anIRInstruction\x0a\x09self instructions remove: anIRInstruction", messageSends: ["remove:", "instructions"], referencedClasses: [] }), smalltalk.IRInstruction); smalltalk.addMethod( "_replace_with_", smalltalk.method({ selector: "replace:with:", category: 'building', fn: function (anIRInstruction,anotherIRInstruction){ var self=this; return smalltalk.withContext(function($ctx1) { _st(anotherIRInstruction)._parent_(self); _st(_st(self)._instructions())._at_put_(_st(_st(self)._instructions())._indexOf_(anIRInstruction),anotherIRInstruction); return self}, function($ctx1) {$ctx1.fill(self,"replace:with:",{anIRInstruction:anIRInstruction,anotherIRInstruction:anotherIRInstruction}, smalltalk.IRInstruction)})}, args: ["anIRInstruction", "anotherIRInstruction"], source: "replace: anIRInstruction with: anotherIRInstruction\x0a\x09anotherIRInstruction parent: self.\x0a\x09self instructions \x0a\x09\x09at: (self instructions indexOf: anIRInstruction)\x0a\x09\x09put: anotherIRInstruction", messageSends: ["parent:", "at:put:", "indexOf:", "instructions"], referencedClasses: [] }), smalltalk.IRInstruction); smalltalk.addMethod( "_replaceWith_", smalltalk.method({ selector: "replaceWith:", category: 'building', fn: function (anIRInstruction){ var self=this; return smalltalk.withContext(function($ctx1) { _st(_st(self)._parent())._replace_with_(self,anIRInstruction); return self}, function($ctx1) {$ctx1.fill(self,"replaceWith:",{anIRInstruction:anIRInstruction}, smalltalk.IRInstruction)})}, args: ["anIRInstruction"], source: "replaceWith: anIRInstruction\x0a\x09self parent replace: self with: anIRInstruction", messageSends: ["replace:with:", "parent"], referencedClasses: [] }), smalltalk.IRInstruction); smalltalk.addMethod( "_on_", smalltalk.method({ selector: "on:", category: 'instance creation', fn: function (aBuilder){ var self=this; return smalltalk.withContext(function($ctx1) { var $2,$3,$1; $2=_st(self)._new(); _st($2)._builder_(aBuilder); $3=_st($2)._yourself(); $1=$3; return $1; }, function($ctx1) {$ctx1.fill(self,"on:",{aBuilder:aBuilder}, smalltalk.IRInstruction.klass)})}, args: ["aBuilder"], source: "on: aBuilder\x0a\x09^ self new\x0a\x09\x09builder: aBuilder;\x0a\x09\x09yourself", messageSends: ["builder:", "new", "yourself"], referencedClasses: [] }), smalltalk.IRInstruction.klass); smalltalk.addClass('IRAssignment', smalltalk.IRInstruction, [], 'Compiler-IR'); smalltalk.addMethod( "_accept_", smalltalk.method({ selector: "accept:", category: 'visiting', fn: function (aVisitor){ var self=this; return smalltalk.withContext(function($ctx1) { var $1; $1=_st(aVisitor)._visitIRAssignment_(self); return $1; }, function($ctx1) {$ctx1.fill(self,"accept:",{aVisitor:aVisitor}, smalltalk.IRAssignment)})}, args: ["aVisitor"], source: "accept: aVisitor\x0a\x09^ aVisitor visitIRAssignment: self", messageSends: ["visitIRAssignment:"], referencedClasses: [] }), smalltalk.IRAssignment); smalltalk.addClass('IRDynamicArray', smalltalk.IRInstruction, [], 'Compiler-IR'); smalltalk.addMethod( "_accept_", smalltalk.method({ selector: "accept:", category: 'visiting', fn: function (aVisitor){ var self=this; return smalltalk.withContext(function($ctx1) { var $1; $1=_st(aVisitor)._visitIRDynamicArray_(self); return $1; }, function($ctx1) {$ctx1.fill(self,"accept:",{aVisitor:aVisitor}, smalltalk.IRDynamicArray)})}, args: ["aVisitor"], source: "accept: aVisitor\x0a\x09^ aVisitor visitIRDynamicArray: self", messageSends: ["visitIRDynamicArray:"], referencedClasses: [] }), smalltalk.IRDynamicArray); smalltalk.addClass('IRDynamicDictionary', smalltalk.IRInstruction, [], 'Compiler-IR'); smalltalk.addMethod( "_accept_", smalltalk.method({ selector: "accept:", category: 'visiting', fn: function (aVisitor){ var self=this; return smalltalk.withContext(function($ctx1) { var $1; $1=_st(aVisitor)._visitIRDynamicDictionary_(self); return $1; }, function($ctx1) {$ctx1.fill(self,"accept:",{aVisitor:aVisitor}, smalltalk.IRDynamicDictionary)})}, args: ["aVisitor"], source: "accept: aVisitor\x0a\x09^ aVisitor visitIRDynamicDictionary: self", messageSends: ["visitIRDynamicDictionary:"], referencedClasses: [] }), smalltalk.IRDynamicDictionary); smalltalk.addClass('IRScopedInstruction', smalltalk.IRInstruction, ['scope'], 'Compiler-IR'); smalltalk.addMethod( "_scope", smalltalk.method({ selector: "scope", category: 'accessing', fn: function (){ var self=this; return smalltalk.withContext(function($ctx1) { var $1; $1=self["@scope"]; return $1; }, function($ctx1) {$ctx1.fill(self,"scope",{}, smalltalk.IRScopedInstruction)})}, args: [], source: "scope\x0a\x09^ scope", messageSends: [], referencedClasses: [] }), smalltalk.IRScopedInstruction); smalltalk.addMethod( "_scope_", smalltalk.method({ selector: "scope:", category: 'accessing', fn: function (aScope){ var self=this; return smalltalk.withContext(function($ctx1) { self["@scope"]=aScope; return self}, function($ctx1) {$ctx1.fill(self,"scope:",{aScope:aScope}, smalltalk.IRScopedInstruction)})}, args: ["aScope"], source: "scope: aScope\x0a\x09scope := aScope", messageSends: [], referencedClasses: [] }), smalltalk.IRScopedInstruction); smalltalk.addClass('IRClosureInstruction', smalltalk.IRScopedInstruction, ['arguments'], 'Compiler-IR'); smalltalk.addMethod( "_arguments", smalltalk.method({ selector: "arguments", category: 'accessing', fn: function (){ var self=this; return smalltalk.withContext(function($ctx1) { var $2,$1; $2=self["@arguments"]; if(($receiver = $2) == nil || $receiver == undefined){ $1=[]; } else { $1=$2; }; return $1; }, function($ctx1) {$ctx1.fill(self,"arguments",{}, smalltalk.IRClosureInstruction)})}, args: [], source: "arguments\x0a\x09^ arguments ifNil: [ #() ]", messageSends: ["ifNil:"], referencedClasses: [] }), smalltalk.IRClosureInstruction); smalltalk.addMethod( "_arguments_", smalltalk.method({ selector: "arguments:", category: 'accessing', fn: function (aCollection){ var self=this; return smalltalk.withContext(function($ctx1) { self["@arguments"]=aCollection; return self}, function($ctx1) {$ctx1.fill(self,"arguments:",{aCollection:aCollection}, smalltalk.IRClosureInstruction)})}, args: ["aCollection"], source: "arguments: aCollection\x0a\x09arguments := aCollection", messageSends: [], referencedClasses: [] }), smalltalk.IRClosureInstruction); smalltalk.addMethod( "_locals", smalltalk.method({ selector: "locals", category: 'accessing', fn: function (){ var self=this; return smalltalk.withContext(function($ctx1) { var $2,$3,$1; $2=_st(_st(self)._arguments())._copy(); _st($2)._addAll_(_st(_st(self)._tempDeclarations())._collect_((function(each){ return smalltalk.withContext(function($ctx2) { return _st(each)._name(); }, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1)})}))); $3=_st($2)._yourself(); $1=$3; return $1; }, function($ctx1) {$ctx1.fill(self,"locals",{}, smalltalk.IRClosureInstruction)})}, args: [], source: "locals\x0a\x09^ self arguments copy\x0a \x09addAll: (self tempDeclarations collect: [ :each | each name ]); \x0a yourself", messageSends: ["addAll:", "collect:", "name", "tempDeclarations", "copy", "arguments", "yourself"], referencedClasses: [] }), smalltalk.IRClosureInstruction); smalltalk.addMethod( "_scope_", smalltalk.method({ selector: "scope:", category: 'accessing', fn: function (aScope){ var self=this; return smalltalk.withContext(function($ctx1) { smalltalk.IRScopedInstruction.fn.prototype._scope_.apply(_st(self), [aScope]); _st(aScope)._instruction_(self); return self}, function($ctx1) {$ctx1.fill(self,"scope:",{aScope:aScope}, smalltalk.IRClosureInstruction)})}, args: ["aScope"], source: "scope: aScope\x0a\x09super scope: aScope.\x0a\x09aScope instruction: self", messageSends: ["scope:", "instruction:"], referencedClasses: [] }), smalltalk.IRClosureInstruction); smalltalk.addMethod( "_tempDeclarations", smalltalk.method({ selector: "tempDeclarations", category: 'accessing', fn: function (){ var self=this; return smalltalk.withContext(function($ctx1) { var $1; $1=_st(_st(self)._instructions())._select_((function(each){ return smalltalk.withContext(function($ctx2) { return _st(each)._isTempDeclaration(); }, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1)})})); return $1; }, function($ctx1) {$ctx1.fill(self,"tempDeclarations",{}, smalltalk.IRClosureInstruction)})}, args: [], source: "tempDeclarations\x0a\x09^ self instructions select: [ :each | \x0a \x09each isTempDeclaration ]", messageSends: ["select:", "isTempDeclaration", "instructions"], referencedClasses: [] }), smalltalk.IRClosureInstruction); smalltalk.addClass('IRClosure', smalltalk.IRClosureInstruction, [], 'Compiler-IR'); smalltalk.addMethod( "_accept_", smalltalk.method({ selector: "accept:", category: 'visiting', fn: function (aVisitor){ var self=this; return smalltalk.withContext(function($ctx1) { var $1; $1=_st(aVisitor)._visitIRClosure_(self); return $1; }, function($ctx1) {$ctx1.fill(self,"accept:",{aVisitor:aVisitor}, smalltalk.IRClosure)})}, args: ["aVisitor"], source: "accept: aVisitor\x0a\x09^ aVisitor visitIRClosure: self", messageSends: ["visitIRClosure:"], referencedClasses: [] }), smalltalk.IRClosure); smalltalk.addMethod( "_isClosure", smalltalk.method({ selector: "isClosure", category: 'testing', fn: function (){ var self=this; return smalltalk.withContext(function($ctx1) { return true; }, function($ctx1) {$ctx1.fill(self,"isClosure",{}, smalltalk.IRClosure)})}, args: [], source: "isClosure\x0a\x09^ true", messageSends: [], referencedClasses: [] }), smalltalk.IRClosure); smalltalk.addMethod( "_sequence", smalltalk.method({ selector: "sequence", category: 'accessing', fn: function (){ var self=this; return smalltalk.withContext(function($ctx1) { var $1; $1=_st(_st(self)._instructions())._last(); return $1; }, function($ctx1) {$ctx1.fill(self,"sequence",{}, smalltalk.IRClosure)})}, args: [], source: "sequence\x0a\x09^ self instructions last", messageSends: ["last", "instructions"], referencedClasses: [] }), smalltalk.IRClosure); smalltalk.addClass('IRMethod', smalltalk.IRClosureInstruction, ['theClass', 'source', 'selector', 'classReferences', 'messageSends', 'superSends', 'internalVariables'], 'Compiler-IR'); smalltalk.IRMethod.comment="I am a method instruction" smalltalk.addMethod( "_accept_", smalltalk.method({ selector: "accept:", category: 'visiting', fn: function (aVisitor){ var self=this; return smalltalk.withContext(function($ctx1) { var $1; $1=_st(aVisitor)._visitIRMethod_(self); return $1; }, function($ctx1) {$ctx1.fill(self,"accept:",{aVisitor:aVisitor}, smalltalk.IRMethod)})}, args: ["aVisitor"], source: "accept: aVisitor\x0a\x09^ aVisitor visitIRMethod: self", messageSends: ["visitIRMethod:"], referencedClasses: [] }), smalltalk.IRMethod); smalltalk.addMethod( "_classReferences", smalltalk.method({ selector: "classReferences", category: 'accessing', fn: function (){ var self=this; return smalltalk.withContext(function($ctx1) { var $1; $1=self["@classReferences"]; return $1; }, function($ctx1) {$ctx1.fill(self,"classReferences",{}, smalltalk.IRMethod)})}, args: [], source: "classReferences\x0a\x09^ classReferences", messageSends: [], referencedClasses: [] }), smalltalk.IRMethod); smalltalk.addMethod( "_classReferences_", smalltalk.method({ selector: "classReferences:", category: 'accessing', fn: function (aCollection){ var self=this; return smalltalk.withContext(function($ctx1) { self["@classReferences"]=aCollection; return self}, function($ctx1) {$ctx1.fill(self,"classReferences:",{aCollection:aCollection}, smalltalk.IRMethod)})}, args: ["aCollection"], source: "classReferences: aCollection\x0a\x09classReferences := aCollection", messageSends: [], referencedClasses: [] }), smalltalk.IRMethod); smalltalk.addMethod( "_internalVariables", smalltalk.method({ selector: "internalVariables", category: 'accessing', fn: function (){ var self=this; return smalltalk.withContext(function($ctx1) { var $2,$1; $2=self["@internalVariables"]; if(($receiver = $2) == nil || $receiver == undefined){ self["@internalVariables"]=_st((smalltalk.Set || Set))._new(); $1=self["@internalVariables"]; } else { $1=$2; }; return $1; }, function($ctx1) {$ctx1.fill(self,"internalVariables",{}, smalltalk.IRMethod)})}, args: [], source: "internalVariables\x0a\x09^ internalVariables ifNil: [ internalVariables := Set new ]", messageSends: ["ifNil:", "new"], referencedClasses: ["Set"] }), smalltalk.IRMethod); smalltalk.addMethod( "_isMethod", smalltalk.method({ selector: "isMethod", category: 'accessing', fn: function (){ var self=this; return smalltalk.withContext(function($ctx1) { return true; }, function($ctx1) {$ctx1.fill(self,"isMethod",{}, smalltalk.IRMethod)})}, args: [], source: "isMethod\x0a\x09^ true", messageSends: [], referencedClasses: [] }), smalltalk.IRMethod); smalltalk.addMethod( "_messageSends", smalltalk.method({ selector: "messageSends", category: 'accessing', fn: function (){ var self=this; return smalltalk.withContext(function($ctx1) { var $1; $1=self["@messageSends"]; return $1; }, function($ctx1) {$ctx1.fill(self,"messageSends",{}, smalltalk.IRMethod)})}, args: [], source: "messageSends\x0a\x09^ messageSends", messageSends: [], referencedClasses: [] }), smalltalk.IRMethod); smalltalk.addMethod( "_messageSends_", smalltalk.method({ selector: "messageSends:", category: 'accessing', fn: function (aCollection){ var self=this; return smalltalk.withContext(function($ctx1) { self["@messageSends"]=aCollection; return self}, function($ctx1) {$ctx1.fill(self,"messageSends:",{aCollection:aCollection}, smalltalk.IRMethod)})}, args: ["aCollection"], source: "messageSends: aCollection\x0a\x09messageSends := aCollection", messageSends: [], referencedClasses: [] }), smalltalk.IRMethod); smalltalk.addMethod( "_method", smalltalk.method({ selector: "method", category: 'accessing', fn: function (){ var self=this; return smalltalk.withContext(function($ctx1) { var $1; $1=self; return $1; }, function($ctx1) {$ctx1.fill(self,"method",{}, smalltalk.IRMethod)})}, args: [], source: "method\x0a\x09^ self", messageSends: [], referencedClasses: [] }), smalltalk.IRMethod); smalltalk.addMethod( "_selector", smalltalk.method({ selector: "selector", category: 'accessing', fn: function (){ var self=this; return smalltalk.withContext(function($ctx1) { var $1; $1=self["@selector"]; return $1; }, function($ctx1) {$ctx1.fill(self,"selector",{}, smalltalk.IRMethod)})}, args: [], source: "selector\x0a\x09^ selector", messageSends: [], referencedClasses: [] }), smalltalk.IRMethod); smalltalk.addMethod( "_selector_", smalltalk.method({ selector: "selector:", category: 'accessing', fn: function (aString){ var self=this; return smalltalk.withContext(function($ctx1) { self["@selector"]=aString; return self}, function($ctx1) {$ctx1.fill(self,"selector:",{aString:aString}, smalltalk.IRMethod)})}, args: ["aString"], source: "selector: aString\x0a\x09selector := aString", messageSends: [], referencedClasses: [] }), smalltalk.IRMethod); smalltalk.addMethod( "_source", smalltalk.method({ selector: "source", category: 'accessing', fn: function (){ var self=this; return smalltalk.withContext(function($ctx1) { var $1; $1=self["@source"]; return $1; }, function($ctx1) {$ctx1.fill(self,"source",{}, smalltalk.IRMethod)})}, args: [], source: "source\x0a\x09^ source", messageSends: [], referencedClasses: [] }), smalltalk.IRMethod); smalltalk.addMethod( "_source_", smalltalk.method({ selector: "source:", category: 'accessing', fn: function (aString){ var self=this; return smalltalk.withContext(function($ctx1) { self["@source"]=aString; return self}, function($ctx1) {$ctx1.fill(self,"source:",{aString:aString}, smalltalk.IRMethod)})}, args: ["aString"], source: "source: aString\x0a\x09source := aString", messageSends: [], referencedClasses: [] }), smalltalk.IRMethod); smalltalk.addMethod( "_superSends", smalltalk.method({ selector: "superSends", category: 'accessing', fn: function (){ var self=this; return smalltalk.withContext(function($ctx1) { var $1; $1=self["@superSends"]; return $1; }, function($ctx1) {$ctx1.fill(self,"superSends",{}, smalltalk.IRMethod)})}, args: [], source: "superSends\x0a\x09^ superSends", messageSends: [], referencedClasses: [] }), smalltalk.IRMethod); smalltalk.addMethod( "_superSends_", smalltalk.method({ selector: "superSends:", category: 'accessing', fn: function (aCollection){ var self=this; return smalltalk.withContext(function($ctx1) { self["@superSends"]=aCollection; return self}, function($ctx1) {$ctx1.fill(self,"superSends:",{aCollection:aCollection}, smalltalk.IRMethod)})}, args: ["aCollection"], source: "superSends: aCollection\x0a\x09superSends := aCollection", messageSends: [], referencedClasses: [] }), smalltalk.IRMethod); smalltalk.addMethod( "_theClass", smalltalk.method({ selector: "theClass", category: 'accessing', fn: function (){ var self=this; return smalltalk.withContext(function($ctx1) { var $1; $1=self["@theClass"]; return $1; }, function($ctx1) {$ctx1.fill(self,"theClass",{}, smalltalk.IRMethod)})}, args: [], source: "theClass\x0a\x09^ theClass", messageSends: [], referencedClasses: [] }), smalltalk.IRMethod); smalltalk.addMethod( "_theClass_", smalltalk.method({ selector: "theClass:", category: 'accessing', fn: function (aClass){ var self=this; return smalltalk.withContext(function($ctx1) { self["@theClass"]=aClass; return self}, function($ctx1) {$ctx1.fill(self,"theClass:",{aClass:aClass}, smalltalk.IRMethod)})}, args: ["aClass"], source: "theClass: aClass\x0a\x09theClass := aClass", messageSends: [], referencedClasses: [] }), smalltalk.IRMethod); smalltalk.addClass('IRReturn', smalltalk.IRScopedInstruction, [], 'Compiler-IR'); smalltalk.IRReturn.comment="I am a local return instruction." smalltalk.addMethod( "_accept_", smalltalk.method({ selector: "accept:", category: 'visiting', fn: function (aVisitor){ var self=this; return smalltalk.withContext(function($ctx1) { var $1; $1=_st(aVisitor)._visitIRReturn_(self); return $1; }, function($ctx1) {$ctx1.fill(self,"accept:",{aVisitor:aVisitor}, smalltalk.IRReturn)})}, args: ["aVisitor"], source: "accept: aVisitor\x0a\x09^ aVisitor visitIRReturn: self", messageSends: ["visitIRReturn:"], referencedClasses: [] }), smalltalk.IRReturn); smalltalk.addMethod( "_canBeAssigned", smalltalk.method({ selector: "canBeAssigned", category: 'testing', fn: function (){ var self=this; return smalltalk.withContext(function($ctx1) { return false; }, function($ctx1) {$ctx1.fill(self,"canBeAssigned",{}, smalltalk.IRReturn)})}, args: [], source: "canBeAssigned\x0a\x09^ false", messageSends: [], referencedClasses: [] }), smalltalk.IRReturn); smalltalk.addMethod( "_isBlockReturn", smalltalk.method({ selector: "isBlockReturn", category: 'testing', fn: function (){ var self=this; return smalltalk.withContext(function($ctx1) { return false; }, function($ctx1) {$ctx1.fill(self,"isBlockReturn",{}, smalltalk.IRReturn)})}, args: [], source: "isBlockReturn\x0a\x09^ false", messageSends: [], referencedClasses: [] }), smalltalk.IRReturn); smalltalk.addMethod( "_isLocalReturn", smalltalk.method({ selector: "isLocalReturn", category: 'testing', fn: function (){ var self=this; return smalltalk.withContext(function($ctx1) { return true; }, function($ctx1) {$ctx1.fill(self,"isLocalReturn",{}, smalltalk.IRReturn)})}, args: [], source: "isLocalReturn\x0a\x09^ true", messageSends: [], referencedClasses: [] }), smalltalk.IRReturn); smalltalk.addMethod( "_isNonLocalReturn", smalltalk.method({ selector: "isNonLocalReturn", category: 'testing', fn: function (){ var self=this; return smalltalk.withContext(function($ctx1) { var $1; $1=_st(_st(self)._isLocalReturn())._not(); return $1; }, function($ctx1) {$ctx1.fill(self,"isNonLocalReturn",{}, smalltalk.IRReturn)})}, args: [], source: "isNonLocalReturn\x0a\x09^ self isLocalReturn not", messageSends: ["not", "isLocalReturn"], referencedClasses: [] }), smalltalk.IRReturn); smalltalk.addMethod( "_isReturn", smalltalk.method({ selector: "isReturn", category: 'testing', fn: function (){ var self=this; return smalltalk.withContext(function($ctx1) { return true; }, function($ctx1) {$ctx1.fill(self,"isReturn",{}, smalltalk.IRReturn)})}, args: [], source: "isReturn\x0a\x09^ true", messageSends: [], referencedClasses: [] }), smalltalk.IRReturn); smalltalk.addClass('IRBlockReturn', smalltalk.IRReturn, [], 'Compiler-IR'); smalltalk.IRBlockReturn.comment="Smalltalk blocks return their last statement. I am a implicit block return instruction." smalltalk.addMethod( "_accept_", smalltalk.method({ selector: "accept:", category: 'visiting', fn: function (aVisitor){ var self=this; return smalltalk.withContext(function($ctx1) { var $1; $1=_st(aVisitor)._visitIRBlockReturn_(self); return $1; }, function($ctx1) {$ctx1.fill(self,"accept:",{aVisitor:aVisitor}, smalltalk.IRBlockReturn)})}, args: ["aVisitor"], source: "accept: aVisitor\x0a\x09^ aVisitor visitIRBlockReturn: self", messageSends: ["visitIRBlockReturn:"], referencedClasses: [] }), smalltalk.IRBlockReturn); smalltalk.addMethod( "_isBlockReturn", smalltalk.method({ selector: "isBlockReturn", category: 'testing', fn: function (){ var self=this; return smalltalk.withContext(function($ctx1) { return true; }, function($ctx1) {$ctx1.fill(self,"isBlockReturn",{}, smalltalk.IRBlockReturn)})}, args: [], source: "isBlockReturn\x0a\x09^ true", messageSends: [], referencedClasses: [] }), smalltalk.IRBlockReturn); smalltalk.addClass('IRNonLocalReturn', smalltalk.IRReturn, [], 'Compiler-IR'); smalltalk.IRNonLocalReturn.comment="I am a non local return instruction.\x0aNon local returns are handled using a try/catch JS statement.\x0a\x0aSee IRNonLocalReturnHandling class" smalltalk.addMethod( "_accept_", smalltalk.method({ selector: "accept:", category: 'visiting', fn: function (aVisitor){ var self=this; return smalltalk.withContext(function($ctx1) { var $1; $1=_st(aVisitor)._visitIRNonLocalReturn_(self); return $1; }, function($ctx1) {$ctx1.fill(self,"accept:",{aVisitor:aVisitor}, smalltalk.IRNonLocalReturn)})}, args: ["aVisitor"], source: "accept: aVisitor\x0a\x09^ aVisitor visitIRNonLocalReturn: self", messageSends: ["visitIRNonLocalReturn:"], referencedClasses: [] }), smalltalk.IRNonLocalReturn); smalltalk.addMethod( "_isLocalReturn", smalltalk.method({ selector: "isLocalReturn", category: 'testing', fn: function (){ var self=this; return smalltalk.withContext(function($ctx1) { return false; }, function($ctx1) {$ctx1.fill(self,"isLocalReturn",{}, smalltalk.IRNonLocalReturn)})}, args: [], source: "isLocalReturn\x0a\x09^ false", messageSends: [], referencedClasses: [] }), smalltalk.IRNonLocalReturn); smalltalk.addClass('IRTempDeclaration', smalltalk.IRScopedInstruction, ['name'], 'Compiler-IR'); smalltalk.addMethod( "_accept_", smalltalk.method({ selector: "accept:", category: 'visiting', fn: function (aVisitor){ var self=this; return smalltalk.withContext(function($ctx1) { var $1; $1=_st(aVisitor)._visitIRTempDeclaration_(self); return $1; }, function($ctx1) {$ctx1.fill(self,"accept:",{aVisitor:aVisitor}, smalltalk.IRTempDeclaration)})}, args: ["aVisitor"], source: "accept: aVisitor\x0a\x09^ aVisitor visitIRTempDeclaration: self", messageSends: ["visitIRTempDeclaration:"], referencedClasses: [] }), smalltalk.IRTempDeclaration); smalltalk.addMethod( "_isTempDeclaration", smalltalk.method({ selector: "isTempDeclaration", category: 'testing', fn: function (){ var self=this; return smalltalk.withContext(function($ctx1) { return true; }, function($ctx1) {$ctx1.fill(self,"isTempDeclaration",{}, smalltalk.IRTempDeclaration)})}, args: [], source: "isTempDeclaration\x0a\x09^ true", messageSends: [], referencedClasses: [] }), smalltalk.IRTempDeclaration); smalltalk.addMethod( "_name", smalltalk.method({ selector: "name", category: 'accessing', fn: function (){ var self=this; return smalltalk.withContext(function($ctx1) { var $1; $1=self["@name"]; return $1; }, function($ctx1) {$ctx1.fill(self,"name",{}, smalltalk.IRTempDeclaration)})}, args: [], source: "name\x0a\x09^ name", messageSends: [], referencedClasses: [] }), smalltalk.IRTempDeclaration); smalltalk.addMethod( "_name_", smalltalk.method({ selector: "name:", category: 'accessing', fn: function (aString){ var self=this; return smalltalk.withContext(function($ctx1) { self["@name"]=aString; return self}, function($ctx1) {$ctx1.fill(self,"name:",{aString:aString}, smalltalk.IRTempDeclaration)})}, args: ["aString"], source: "name: aString\x0a\x09name := aString", messageSends: [], referencedClasses: [] }), smalltalk.IRTempDeclaration); smalltalk.addClass('IRSend', smalltalk.IRInstruction, ['selector', 'classSend', 'index'], 'Compiler-IR'); smalltalk.IRSend.comment="I am a message send instruction." smalltalk.addMethod( "_accept_", smalltalk.method({ selector: "accept:", category: 'visiting', fn: function (aVisitor){ var self=this; return smalltalk.withContext(function($ctx1) { var $1; $1=_st(aVisitor)._visitIRSend_(self); return $1; }, function($ctx1) {$ctx1.fill(self,"accept:",{aVisitor:aVisitor}, smalltalk.IRSend)})}, args: ["aVisitor"], source: "accept: aVisitor\x0a\x09^ aVisitor visitIRSend: self", messageSends: ["visitIRSend:"], referencedClasses: [] }), smalltalk.IRSend); smalltalk.addMethod( "_classSend", smalltalk.method({ selector: "classSend", category: 'accessing', fn: function (){ var self=this; return smalltalk.withContext(function($ctx1) { var $1; $1=self["@classSend"]; return $1; }, function($ctx1) {$ctx1.fill(self,"classSend",{}, smalltalk.IRSend)})}, args: [], source: "classSend\x0a\x09^ classSend", messageSends: [], referencedClasses: [] }), smalltalk.IRSend); smalltalk.addMethod( "_classSend_", smalltalk.method({ selector: "classSend:", category: 'accessing', fn: function (aClass){ var self=this; return smalltalk.withContext(function($ctx1) { self["@classSend"]=aClass; return self}, function($ctx1) {$ctx1.fill(self,"classSend:",{aClass:aClass}, smalltalk.IRSend)})}, args: ["aClass"], source: "classSend: aClass\x0a\x09classSend := aClass", messageSends: [], referencedClasses: [] }), smalltalk.IRSend); smalltalk.addMethod( "_index", smalltalk.method({ selector: "index", category: 'accessing', fn: function (){ var self=this; return smalltalk.withContext(function($ctx1) { var $1; $1=self["@index"]; return $1; }, function($ctx1) {$ctx1.fill(self,"index",{}, smalltalk.IRSend)})}, args: [], source: "index\x0a\x09^ index", messageSends: [], referencedClasses: [] }), smalltalk.IRSend); smalltalk.addMethod( "_index_", smalltalk.method({ selector: "index:", category: 'accessing', fn: function (anInteger){ var self=this; return smalltalk.withContext(function($ctx1) { self["@index"]=anInteger; return self}, function($ctx1) {$ctx1.fill(self,"index:",{anInteger:anInteger}, smalltalk.IRSend)})}, args: ["anInteger"], source: "index: anInteger\x0a\x09index := anInteger", messageSends: [], referencedClasses: [] }), smalltalk.IRSend); smalltalk.addMethod( "_isSend", smalltalk.method({ selector: "isSend", category: 'testing', fn: function (){ var self=this; return smalltalk.withContext(function($ctx1) { return true; }, function($ctx1) {$ctx1.fill(self,"isSend",{}, smalltalk.IRSend)})}, args: [], source: "isSend\x0a\x09^ true", messageSends: [], referencedClasses: [] }), smalltalk.IRSend); smalltalk.addMethod( "_javascriptSelector", smalltalk.method({ selector: "javascriptSelector", category: 'accessing', fn: function (){ var self=this; return smalltalk.withContext(function($ctx1) { var $2,$1; $2=_st(self)._classSend(); if(($receiver = $2) == nil || $receiver == undefined){ $1=_st(_st(self)._selector())._asSelector(); } else { $1=_st(_st(self)._selector())._asSuperSelector(); }; return $1; }, function($ctx1) {$ctx1.fill(self,"javascriptSelector",{}, smalltalk.IRSend)})}, args: [], source: "javascriptSelector\x0a\x09^ self classSend \x0a \x09ifNil: [ self selector asSelector ]\x0a \x09ifNotNil: [ self selector asSuperSelector ]", messageSends: ["ifNil:ifNotNil:", "asSelector", "selector", "asSuperSelector", "classSend"], referencedClasses: [] }), smalltalk.IRSend); smalltalk.addMethod( "_selector", smalltalk.method({ selector: "selector", category: 'accessing', fn: function (){ var self=this; return smalltalk.withContext(function($ctx1) { var $1; $1=self["@selector"]; return $1; }, function($ctx1) {$ctx1.fill(self,"selector",{}, smalltalk.IRSend)})}, args: [], source: "selector\x0a\x09^ selector", messageSends: [], referencedClasses: [] }), smalltalk.IRSend); smalltalk.addMethod( "_selector_", smalltalk.method({ selector: "selector:", category: 'accessing', fn: function (aString){ var self=this; return smalltalk.withContext(function($ctx1) { self["@selector"]=aString; return self}, function($ctx1) {$ctx1.fill(self,"selector:",{aString:aString}, smalltalk.IRSend)})}, args: ["aString"], source: "selector: aString\x0a\x09selector := aString", messageSends: [], referencedClasses: [] }), smalltalk.IRSend); smalltalk.addClass('IRSequence', smalltalk.IRInstruction, [], 'Compiler-IR'); smalltalk.addMethod( "_accept_", smalltalk.method({ selector: "accept:", category: 'visiting', fn: function (aVisitor){ var self=this; return smalltalk.withContext(function($ctx1) { var $1; $1=_st(aVisitor)._visitIRSequence_(self); return $1; }, function($ctx1) {$ctx1.fill(self,"accept:",{aVisitor:aVisitor}, smalltalk.IRSequence)})}, args: ["aVisitor"], source: "accept: aVisitor\x0a\x09^ aVisitor visitIRSequence: self", messageSends: ["visitIRSequence:"], referencedClasses: [] }), smalltalk.IRSequence); smalltalk.addMethod( "_isSequence", smalltalk.method({ selector: "isSequence", category: 'testing', fn: function (){ var self=this; return smalltalk.withContext(function($ctx1) { return true; }, function($ctx1) {$ctx1.fill(self,"isSequence",{}, smalltalk.IRSequence)})}, args: [], source: "isSequence\x0a\x09^ true", messageSends: [], referencedClasses: [] }), smalltalk.IRSequence); smalltalk.addClass('IRBlockSequence', smalltalk.IRSequence, [], 'Compiler-IR'); smalltalk.addMethod( "_accept_", smalltalk.method({ selector: "accept:", category: 'visiting', fn: function (aVisitor){ var self=this; return smalltalk.withContext(function($ctx1) { var $1; $1=_st(aVisitor)._visitIRBlockSequence_(self); return $1; }, function($ctx1) {$ctx1.fill(self,"accept:",{aVisitor:aVisitor}, smalltalk.IRBlockSequence)})}, args: ["aVisitor"], source: "accept: aVisitor\x0a\x09^ aVisitor visitIRBlockSequence: self", messageSends: ["visitIRBlockSequence:"], referencedClasses: [] }), smalltalk.IRBlockSequence); smalltalk.addClass('IRValue', smalltalk.IRInstruction, ['value'], 'Compiler-IR'); smalltalk.IRValue.comment="I am the simplest possible instruction. I represent a value." smalltalk.addMethod( "_accept_", smalltalk.method({ selector: "accept:", category: 'visiting', fn: function (aVisitor){ var self=this; return smalltalk.withContext(function($ctx1) { var $1; $1=_st(aVisitor)._visitIRValue_(self); return $1; }, function($ctx1) {$ctx1.fill(self,"accept:",{aVisitor:aVisitor}, smalltalk.IRValue)})}, args: ["aVisitor"], source: "accept: aVisitor\x0a\x09^ aVisitor visitIRValue: self", messageSends: ["visitIRValue:"], referencedClasses: [] }), smalltalk.IRValue); smalltalk.addMethod( "_value", smalltalk.method({ selector: "value", category: 'accessing', fn: function (){ var self=this; return smalltalk.withContext(function($ctx1) { var $1; $1=self["@value"]; return $1; }, function($ctx1) {$ctx1.fill(self,"value",{}, smalltalk.IRValue)})}, args: [], source: "value\x0a\x09^value", messageSends: [], referencedClasses: [] }), smalltalk.IRValue); smalltalk.addMethod( "_value_", smalltalk.method({ selector: "value:", category: 'accessing', fn: function (aString){ var self=this; return smalltalk.withContext(function($ctx1) { self["@value"]=aString; return self}, function($ctx1) {$ctx1.fill(self,"value:",{aString:aString}, smalltalk.IRValue)})}, args: ["aString"], source: "value: aString\x0a\x09value := aString", messageSends: [], referencedClasses: [] }), smalltalk.IRValue); smalltalk.addClass('IRVariable', smalltalk.IRInstruction, ['variable'], 'Compiler-IR'); smalltalk.IRVariable.comment="I am a variable instruction." smalltalk.addMethod( "_accept_", smalltalk.method({ selector: "accept:", category: 'visiting', fn: function (aVisitor){ var self=this; return smalltalk.withContext(function($ctx1) { var $1; $1=_st(aVisitor)._visitIRVariable_(self); return $1; }, function($ctx1) {$ctx1.fill(self,"accept:",{aVisitor:aVisitor}, smalltalk.IRVariable)})}, args: ["aVisitor"], source: "accept: aVisitor\x0a\x09^ aVisitor visitIRVariable: self", messageSends: ["visitIRVariable:"], referencedClasses: [] }), smalltalk.IRVariable); smalltalk.addMethod( "_isVariable", smalltalk.method({ selector: "isVariable", category: 'testing', fn: function (){ var self=this; return smalltalk.withContext(function($ctx1) { return true; }, function($ctx1) {$ctx1.fill(self,"isVariable",{}, smalltalk.IRVariable)})}, args: [], source: "isVariable\x0a\x09^ true", messageSends: [], referencedClasses: [] }), smalltalk.IRVariable); smalltalk.addMethod( "_variable", smalltalk.method({ selector: "variable", category: 'accessing', fn: function (){ var self=this; return smalltalk.withContext(function($ctx1) { var $1; $1=self["@variable"]; return $1; }, function($ctx1) {$ctx1.fill(self,"variable",{}, smalltalk.IRVariable)})}, args: [], source: "variable\x0a\x09^ variable", messageSends: [], referencedClasses: [] }), smalltalk.IRVariable); smalltalk.addMethod( "_variable_", smalltalk.method({ selector: "variable:", category: 'accessing', fn: function (aScopeVariable){ var self=this; return smalltalk.withContext(function($ctx1) { self["@variable"]=aScopeVariable; return self}, function($ctx1) {$ctx1.fill(self,"variable:",{aScopeVariable:aScopeVariable}, smalltalk.IRVariable)})}, args: ["aScopeVariable"], source: "variable: aScopeVariable\x0a\x09variable := aScopeVariable", messageSends: [], referencedClasses: [] }), smalltalk.IRVariable); smalltalk.addClass('IRVerbatim', smalltalk.IRInstruction, ['source'], 'Compiler-IR'); smalltalk.addMethod( "_accept_", smalltalk.method({ selector: "accept:", category: 'visiting', fn: function (aVisitor){ var self=this; return smalltalk.withContext(function($ctx1) { var $1; $1=_st(aVisitor)._visitIRVerbatim_(self); return $1; }, function($ctx1) {$ctx1.fill(self,"accept:",{aVisitor:aVisitor}, smalltalk.IRVerbatim)})}, args: ["aVisitor"], source: "accept: aVisitor\x0a\x09^ aVisitor visitIRVerbatim: self", messageSends: ["visitIRVerbatim:"], referencedClasses: [] }), smalltalk.IRVerbatim); smalltalk.addMethod( "_source", smalltalk.method({ selector: "source", category: 'accessing', fn: function (){ var self=this; return smalltalk.withContext(function($ctx1) { var $1; $1=self["@source"]; return $1; }, function($ctx1) {$ctx1.fill(self,"source",{}, smalltalk.IRVerbatim)})}, args: [], source: "source\x0a\x09^ source", messageSends: [], referencedClasses: [] }), smalltalk.IRVerbatim); smalltalk.addMethod( "_source_", smalltalk.method({ selector: "source:", category: 'accessing', fn: function (aString){ var self=this; return smalltalk.withContext(function($ctx1) { self["@source"]=aString; return self}, function($ctx1) {$ctx1.fill(self,"source:",{aString:aString}, smalltalk.IRVerbatim)})}, args: ["aString"], source: "source: aString\x0a\x09source := aString", messageSends: [], referencedClasses: [] }), smalltalk.IRVerbatim); smalltalk.addClass('IRVisitor', smalltalk.Object, [], 'Compiler-IR'); smalltalk.addMethod( "_visit_", smalltalk.method({ selector: "visit:", category: 'visiting', fn: function (anIRInstruction){ var self=this; return smalltalk.withContext(function($ctx1) { var $1; $1=_st(anIRInstruction)._accept_(self); return $1; }, function($ctx1) {$ctx1.fill(self,"visit:",{anIRInstruction:anIRInstruction}, smalltalk.IRVisitor)})}, args: ["anIRInstruction"], source: "visit: anIRInstruction\x0a\x09^ anIRInstruction accept: self", messageSends: ["accept:"], referencedClasses: [] }), smalltalk.IRVisitor); smalltalk.addMethod( "_visitIRAssignment_", smalltalk.method({ selector: "visitIRAssignment:", category: 'visiting', fn: function (anIRAssignment){ var self=this; return smalltalk.withContext(function($ctx1) { var $1; $1=_st(self)._visitIRInstruction_(anIRAssignment); return $1; }, function($ctx1) {$ctx1.fill(self,"visitIRAssignment:",{anIRAssignment:anIRAssignment}, smalltalk.IRVisitor)})}, args: ["anIRAssignment"], source: "visitIRAssignment: anIRAssignment\x0a\x09^ self visitIRInstruction: anIRAssignment", messageSends: ["visitIRInstruction:"], referencedClasses: [] }), smalltalk.IRVisitor); smalltalk.addMethod( "_visitIRBlockReturn_", smalltalk.method({ selector: "visitIRBlockReturn:", category: 'visiting', fn: function (anIRBlockReturn){ var self=this; return smalltalk.withContext(function($ctx1) { var $1; $1=_st(self)._visitIRReturn_(anIRBlockReturn); return $1; }, function($ctx1) {$ctx1.fill(self,"visitIRBlockReturn:",{anIRBlockReturn:anIRBlockReturn}, smalltalk.IRVisitor)})}, args: ["anIRBlockReturn"], source: "visitIRBlockReturn: anIRBlockReturn\x0a\x09^ self visitIRReturn: anIRBlockReturn", messageSends: ["visitIRReturn:"], referencedClasses: [] }), smalltalk.IRVisitor); smalltalk.addMethod( "_visitIRBlockSequence_", smalltalk.method({ selector: "visitIRBlockSequence:", category: 'visiting', fn: function (anIRBlockSequence){ var self=this; return smalltalk.withContext(function($ctx1) { var $1; $1=_st(self)._visitIRSequence_(anIRBlockSequence); return $1; }, function($ctx1) {$ctx1.fill(self,"visitIRBlockSequence:",{anIRBlockSequence:anIRBlockSequence}, smalltalk.IRVisitor)})}, args: ["anIRBlockSequence"], source: "visitIRBlockSequence: anIRBlockSequence\x0a\x09^ self visitIRSequence: anIRBlockSequence", messageSends: ["visitIRSequence:"], referencedClasses: [] }), smalltalk.IRVisitor); smalltalk.addMethod( "_visitIRClosure_", smalltalk.method({ selector: "visitIRClosure:", category: 'visiting', fn: function (anIRClosure){ var self=this; return smalltalk.withContext(function($ctx1) { var $1; $1=_st(self)._visitIRInstruction_(anIRClosure); return $1; }, function($ctx1) {$ctx1.fill(self,"visitIRClosure:",{anIRClosure:anIRClosure}, smalltalk.IRVisitor)})}, args: ["anIRClosure"], source: "visitIRClosure: anIRClosure\x0a\x09^ self visitIRInstruction: anIRClosure", messageSends: ["visitIRInstruction:"], referencedClasses: [] }), smalltalk.IRVisitor); smalltalk.addMethod( "_visitIRDynamicArray_", smalltalk.method({ selector: "visitIRDynamicArray:", category: 'visiting', fn: function (anIRDynamicArray){ var self=this; return smalltalk.withContext(function($ctx1) { var $1; $1=_st(self)._visitIRInstruction_(anIRDynamicArray); return $1; }, function($ctx1) {$ctx1.fill(self,"visitIRDynamicArray:",{anIRDynamicArray:anIRDynamicArray}, smalltalk.IRVisitor)})}, args: ["anIRDynamicArray"], source: "visitIRDynamicArray: anIRDynamicArray\x0a\x09^ self visitIRInstruction: anIRDynamicArray", messageSends: ["visitIRInstruction:"], referencedClasses: [] }), smalltalk.IRVisitor); smalltalk.addMethod( "_visitIRDynamicDictionary_", smalltalk.method({ selector: "visitIRDynamicDictionary:", category: 'visiting', fn: function (anIRDynamicDictionary){ var self=this; return smalltalk.withContext(function($ctx1) { var $1; $1=_st(self)._visitIRInstruction_(anIRDynamicDictionary); return $1; }, function($ctx1) {$ctx1.fill(self,"visitIRDynamicDictionary:",{anIRDynamicDictionary:anIRDynamicDictionary}, smalltalk.IRVisitor)})}, args: ["anIRDynamicDictionary"], source: "visitIRDynamicDictionary: anIRDynamicDictionary\x0a\x09^ self visitIRInstruction: anIRDynamicDictionary", messageSends: ["visitIRInstruction:"], referencedClasses: [] }), smalltalk.IRVisitor); smalltalk.addMethod( "_visitIRInlinedClosure_", smalltalk.method({ selector: "visitIRInlinedClosure:", category: 'visiting', fn: function (anIRInlinedClosure){ var self=this; return smalltalk.withContext(function($ctx1) { var $1; $1=_st(self)._visitIRClosure_(anIRInlinedClosure); return $1; }, function($ctx1) {$ctx1.fill(self,"visitIRInlinedClosure:",{anIRInlinedClosure:anIRInlinedClosure}, smalltalk.IRVisitor)})}, args: ["anIRInlinedClosure"], source: "visitIRInlinedClosure: anIRInlinedClosure\x0a\x09^ self visitIRClosure: anIRInlinedClosure", messageSends: ["visitIRClosure:"], referencedClasses: [] }), smalltalk.IRVisitor); smalltalk.addMethod( "_visitIRInlinedSequence_", smalltalk.method({ selector: "visitIRInlinedSequence:", category: 'visiting', fn: function (anIRInlinedSequence){ var self=this; return smalltalk.withContext(function($ctx1) { var $1; $1=_st(self)._visitIRSequence_(anIRInlinedSequence); return $1; }, function($ctx1) {$ctx1.fill(self,"visitIRInlinedSequence:",{anIRInlinedSequence:anIRInlinedSequence}, smalltalk.IRVisitor)})}, args: ["anIRInlinedSequence"], source: "visitIRInlinedSequence: anIRInlinedSequence\x0a\x09^ self visitIRSequence: anIRInlinedSequence", messageSends: ["visitIRSequence:"], referencedClasses: [] }), smalltalk.IRVisitor); smalltalk.addMethod( "_visitIRInstruction_", smalltalk.method({ selector: "visitIRInstruction:", category: 'visiting', fn: function (anIRInstruction){ var self=this; return smalltalk.withContext(function($ctx1) { var $1; _st(_st(anIRInstruction)._instructions())._do_((function(each){ return smalltalk.withContext(function($ctx2) { return _st(self)._visit_(each); }, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1)})})); $1=anIRInstruction; return $1; }, function($ctx1) {$ctx1.fill(self,"visitIRInstruction:",{anIRInstruction:anIRInstruction}, smalltalk.IRVisitor)})}, args: ["anIRInstruction"], source: "visitIRInstruction: anIRInstruction\x0a\x09anIRInstruction instructions do: [ :each | self visit: each ].\x0a\x09^ anIRInstruction", messageSends: ["do:", "visit:", "instructions"], referencedClasses: [] }), smalltalk.IRVisitor); smalltalk.addMethod( "_visitIRMethod_", smalltalk.method({ selector: "visitIRMethod:", category: 'visiting', fn: function (anIRMethod){ var self=this; return smalltalk.withContext(function($ctx1) { var $1; $1=_st(self)._visitIRInstruction_(anIRMethod); return $1; }, function($ctx1) {$ctx1.fill(self,"visitIRMethod:",{anIRMethod:anIRMethod}, smalltalk.IRVisitor)})}, args: ["anIRMethod"], source: "visitIRMethod: anIRMethod\x0a\x09^ self visitIRInstruction: anIRMethod", messageSends: ["visitIRInstruction:"], referencedClasses: [] }), smalltalk.IRVisitor); smalltalk.addMethod( "_visitIRNonLocalReturn_", smalltalk.method({ selector: "visitIRNonLocalReturn:", category: 'visiting', fn: function (anIRNonLocalReturn){ var self=this; return smalltalk.withContext(function($ctx1) { var $1; $1=_st(self)._visitIRInstruction_(anIRNonLocalReturn); return $1; }, function($ctx1) {$ctx1.fill(self,"visitIRNonLocalReturn:",{anIRNonLocalReturn:anIRNonLocalReturn}, smalltalk.IRVisitor)})}, args: ["anIRNonLocalReturn"], source: "visitIRNonLocalReturn: anIRNonLocalReturn\x0a\x09^ self visitIRInstruction: anIRNonLocalReturn", messageSends: ["visitIRInstruction:"], referencedClasses: [] }), smalltalk.IRVisitor); smalltalk.addMethod( "_visitIRNonLocalReturnHandling_", smalltalk.method({ selector: "visitIRNonLocalReturnHandling:", category: 'visiting', fn: function (anIRNonLocalReturnHandling){ var self=this; return smalltalk.withContext(function($ctx1) { var $1; $1=_st(self)._visitIRInstruction_(anIRNonLocalReturnHandling); return $1; }, function($ctx1) {$ctx1.fill(self,"visitIRNonLocalReturnHandling:",{anIRNonLocalReturnHandling:anIRNonLocalReturnHandling}, smalltalk.IRVisitor)})}, args: ["anIRNonLocalReturnHandling"], source: "visitIRNonLocalReturnHandling: anIRNonLocalReturnHandling\x0a\x09^ self visitIRInstruction: anIRNonLocalReturnHandling", messageSends: ["visitIRInstruction:"], referencedClasses: [] }), smalltalk.IRVisitor); smalltalk.addMethod( "_visitIRReturn_", smalltalk.method({ selector: "visitIRReturn:", category: 'visiting', fn: function (anIRReturn){ var self=this; return smalltalk.withContext(function($ctx1) { var $1; $1=_st(self)._visitIRInstruction_(anIRReturn); return $1; }, function($ctx1) {$ctx1.fill(self,"visitIRReturn:",{anIRReturn:anIRReturn}, smalltalk.IRVisitor)})}, args: ["anIRReturn"], source: "visitIRReturn: anIRReturn\x0a\x09^ self visitIRInstruction: anIRReturn", messageSends: ["visitIRInstruction:"], referencedClasses: [] }), smalltalk.IRVisitor); smalltalk.addMethod( "_visitIRSend_", smalltalk.method({ selector: "visitIRSend:", category: 'visiting', fn: function (anIRSend){ var self=this; return smalltalk.withContext(function($ctx1) { var $1; $1=_st(self)._visitIRInstruction_(anIRSend); return $1; }, function($ctx1) {$ctx1.fill(self,"visitIRSend:",{anIRSend:anIRSend}, smalltalk.IRVisitor)})}, args: ["anIRSend"], source: "visitIRSend: anIRSend\x0a\x09^ self visitIRInstruction: anIRSend", messageSends: ["visitIRInstruction:"], referencedClasses: [] }), smalltalk.IRVisitor); smalltalk.addMethod( "_visitIRSequence_", smalltalk.method({ selector: "visitIRSequence:", category: 'visiting', fn: function (anIRSequence){ var self=this; return smalltalk.withContext(function($ctx1) { var $1; $1=_st(self)._visitIRInstruction_(anIRSequence); return $1; }, function($ctx1) {$ctx1.fill(self,"visitIRSequence:",{anIRSequence:anIRSequence}, smalltalk.IRVisitor)})}, args: ["anIRSequence"], source: "visitIRSequence: anIRSequence\x0a\x09^ self visitIRInstruction: anIRSequence", messageSends: ["visitIRInstruction:"], referencedClasses: [] }), smalltalk.IRVisitor); smalltalk.addMethod( "_visitIRTempDeclaration_", smalltalk.method({ selector: "visitIRTempDeclaration:", category: 'visiting', fn: function (anIRTempDeclaration){ var self=this; return smalltalk.withContext(function($ctx1) { var $1; $1=_st(self)._visitIRInstruction_(anIRTempDeclaration); return $1; }, function($ctx1) {$ctx1.fill(self,"visitIRTempDeclaration:",{anIRTempDeclaration:anIRTempDeclaration}, smalltalk.IRVisitor)})}, args: ["anIRTempDeclaration"], source: "visitIRTempDeclaration: anIRTempDeclaration\x0a\x09^ self visitIRInstruction: anIRTempDeclaration", messageSends: ["visitIRInstruction:"], referencedClasses: [] }), smalltalk.IRVisitor); smalltalk.addMethod( "_visitIRValue_", smalltalk.method({ selector: "visitIRValue:", category: 'visiting', fn: function (anIRValue){ var self=this; return smalltalk.withContext(function($ctx1) { var $1; $1=_st(self)._visitIRInstruction_(anIRValue); return $1; }, function($ctx1) {$ctx1.fill(self,"visitIRValue:",{anIRValue:anIRValue}, smalltalk.IRVisitor)})}, args: ["anIRValue"], source: "visitIRValue: anIRValue\x0a\x09^ self visitIRInstruction: anIRValue", messageSends: ["visitIRInstruction:"], referencedClasses: [] }), smalltalk.IRVisitor); smalltalk.addMethod( "_visitIRVariable_", smalltalk.method({ selector: "visitIRVariable:", category: 'visiting', fn: function (anIRVariable){ var self=this; return smalltalk.withContext(function($ctx1) { var $1; $1=_st(self)._visitIRInstruction_(anIRVariable); return $1; }, function($ctx1) {$ctx1.fill(self,"visitIRVariable:",{anIRVariable:anIRVariable}, smalltalk.IRVisitor)})}, args: ["anIRVariable"], source: "visitIRVariable: anIRVariable\x0a\x09^ self visitIRInstruction: anIRVariable", messageSends: ["visitIRInstruction:"], referencedClasses: [] }), smalltalk.IRVisitor); smalltalk.addMethod( "_visitIRVerbatim_", smalltalk.method({ selector: "visitIRVerbatim:", category: 'visiting', fn: function (anIRVerbatim){ var self=this; return smalltalk.withContext(function($ctx1) { var $1; $1=_st(self)._visitIRInstruction_(anIRVerbatim); return $1; }, function($ctx1) {$ctx1.fill(self,"visitIRVerbatim:",{anIRVerbatim:anIRVerbatim}, smalltalk.IRVisitor)})}, args: ["anIRVerbatim"], source: "visitIRVerbatim: anIRVerbatim\x0a\x09^ self visitIRInstruction: anIRVerbatim", messageSends: ["visitIRInstruction:"], referencedClasses: [] }), smalltalk.IRVisitor); smalltalk.addClass('IRJSTranslator', smalltalk.IRVisitor, ['stream'], 'Compiler-IR'); smalltalk.addMethod( "_contents", smalltalk.method({ selector: "contents", category: 'accessing', fn: function (){ var self=this; return smalltalk.withContext(function($ctx1) { var $1; $1=_st(_st(self)._stream())._contents(); return $1; }, function($ctx1) {$ctx1.fill(self,"contents",{}, smalltalk.IRJSTranslator)})}, args: [], source: "contents\x0a\x09^ self stream contents", messageSends: ["contents", "stream"], referencedClasses: [] }), smalltalk.IRJSTranslator); smalltalk.addMethod( "_initialize", smalltalk.method({ selector: "initialize", category: 'initialization', fn: function (){ var self=this; return smalltalk.withContext(function($ctx1) { smalltalk.IRVisitor.fn.prototype._initialize.apply(_st(self), []); self["@stream"]=_st((smalltalk.JSStream || JSStream))._new(); return self}, function($ctx1) {$ctx1.fill(self,"initialize",{}, smalltalk.IRJSTranslator)})}, args: [], source: "initialize\x0a\x09super initialize.\x0a\x09stream := JSStream new.", messageSends: ["initialize", "new"], referencedClasses: ["JSStream"] }), smalltalk.IRJSTranslator); smalltalk.addMethod( "_stream", smalltalk.method({ selector: "stream", category: 'accessing', fn: function (){ var self=this; return smalltalk.withContext(function($ctx1) { var $1; $1=self["@stream"]; return $1; }, function($ctx1) {$ctx1.fill(self,"stream",{}, smalltalk.IRJSTranslator)})}, args: [], source: "stream\x0a\x09^ stream", messageSends: [], referencedClasses: [] }), smalltalk.IRJSTranslator); smalltalk.addMethod( "_stream_", smalltalk.method({ selector: "stream:", category: 'accessing', fn: function (aStream){ var self=this; return smalltalk.withContext(function($ctx1) { self["@stream"]=aStream; return self}, function($ctx1) {$ctx1.fill(self,"stream:",{aStream:aStream}, smalltalk.IRJSTranslator)})}, args: ["aStream"], source: "stream: aStream\x0a\x09stream := aStream", messageSends: [], referencedClasses: [] }), smalltalk.IRJSTranslator); smalltalk.addMethod( "_visitIRAssignment_", smalltalk.method({ selector: "visitIRAssignment:", category: 'visiting', fn: function (anIRAssignment){ var self=this; return smalltalk.withContext(function($ctx1) { _st(self)._visit_(_st(_st(anIRAssignment)._instructions())._first()); _st(_st(self)._stream())._nextPutAssignment(); _st(self)._visit_(_st(_st(anIRAssignment)._instructions())._last()); return self}, function($ctx1) {$ctx1.fill(self,"visitIRAssignment:",{anIRAssignment:anIRAssignment}, smalltalk.IRJSTranslator)})}, args: ["anIRAssignment"], source: "visitIRAssignment: anIRAssignment\x0a\x09self visit: anIRAssignment instructions first.\x0a\x09self stream nextPutAssignment.\x0a\x09self visit: anIRAssignment instructions last.", messageSends: ["visit:", "first", "instructions", "nextPutAssignment", "stream", "last"], referencedClasses: [] }), smalltalk.IRJSTranslator); smalltalk.addMethod( "_visitIRClosure_", smalltalk.method({ selector: "visitIRClosure:", category: 'visiting', fn: function (anIRClosure){ var self=this; return smalltalk.withContext(function($ctx1) { _st(_st(self)._stream())._nextPutClosureWith_arguments_((function(){ return smalltalk.withContext(function($ctx2) { _st(_st(self)._stream())._nextPutVars_(_st(_st(anIRClosure)._tempDeclarations())._collect_((function(each){ return smalltalk.withContext(function($ctx3) { return _st(_st(each)._name())._asVariableName(); }, function($ctx3) {$ctx3.fillBlock({each:each},$ctx1)})}))); return _st(_st(self)._stream())._nextPutBlockContextFor_during_(anIRClosure,(function(){ return smalltalk.withContext(function($ctx3) { return smalltalk.IRVisitor.fn.prototype._visitIRClosure_.apply(_st(self), [anIRClosure]); }, function($ctx3) {$ctx3.fillBlock({},$ctx1)})})); }, function($ctx2) {$ctx2.fillBlock({},$ctx1)})}),_st(anIRClosure)._arguments()); return self}, function($ctx1) {$ctx1.fill(self,"visitIRClosure:",{anIRClosure:anIRClosure}, smalltalk.IRJSTranslator)})}, args: ["anIRClosure"], source: "visitIRClosure: anIRClosure\x0a\x09self stream \x0a\x09\x09nextPutClosureWith: [ \x0a \x09self stream nextPutVars: (anIRClosure tempDeclarations collect: [ :each |\x0a \x09\x09\x09\x09each name asVariableName ]).\x0a \x09self stream \x0a \x09nextPutBlockContextFor: anIRClosure\x0a during: [ super visitIRClosure: anIRClosure ] ]\x0a\x09\x09arguments: anIRClosure arguments", messageSends: ["nextPutClosureWith:arguments:", "nextPutVars:", "collect:", "asVariableName", "name", "tempDeclarations", "stream", "nextPutBlockContextFor:during:", "visitIRClosure:", "arguments"], referencedClasses: [] }), smalltalk.IRJSTranslator); smalltalk.addMethod( "_visitIRDynamicArray_", smalltalk.method({ selector: "visitIRDynamicArray:", category: 'visiting', fn: function (anIRDynamicArray){ var self=this; return smalltalk.withContext(function($ctx1) { _st(_st(self)._stream())._nextPutAll_("["); _st(_st(anIRDynamicArray)._instructions())._do_separatedBy_((function(each){ return smalltalk.withContext(function($ctx2) { return _st(self)._visit_(each); }, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1)})}),(function(){ return smalltalk.withContext(function($ctx2) { return _st(_st(self)._stream())._nextPutAll_(","); }, function($ctx2) {$ctx2.fillBlock({},$ctx1)})})); _st(self["@stream"])._nextPutAll_("]"); return self}, function($ctx1) {$ctx1.fill(self,"visitIRDynamicArray:",{anIRDynamicArray:anIRDynamicArray}, smalltalk.IRJSTranslator)})}, args: ["anIRDynamicArray"], source: "visitIRDynamicArray: anIRDynamicArray\x0a\x09self stream nextPutAll: '['.\x0a\x09anIRDynamicArray instructions\x0a\x09\x09do: [ :each | self visit: each ]\x0a\x09\x09separatedBy: [ self stream nextPutAll: ',' ].\x0a\x09stream nextPutAll: ']'", messageSends: ["nextPutAll:", "stream", "do:separatedBy:", "visit:", "instructions"], referencedClasses: [] }), smalltalk.IRJSTranslator); smalltalk.addMethod( "_visitIRDynamicDictionary_", smalltalk.method({ selector: "visitIRDynamicDictionary:", category: 'visiting', fn: function (anIRDynamicDictionary){ var self=this; return smalltalk.withContext(function($ctx1) { _st(_st(self)._stream())._nextPutAll_("smalltalk.HashedCollection._fromPairs_(["); _st(_st(anIRDynamicDictionary)._instructions())._do_separatedBy_((function(each){ return smalltalk.withContext(function($ctx2) { return _st(self)._visit_(each); }, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1)})}),(function(){ return smalltalk.withContext(function($ctx2) { return _st(_st(self)._stream())._nextPutAll_(","); }, function($ctx2) {$ctx2.fillBlock({},$ctx1)})})); _st(_st(self)._stream())._nextPutAll_("])"); return self}, function($ctx1) {$ctx1.fill(self,"visitIRDynamicDictionary:",{anIRDynamicDictionary:anIRDynamicDictionary}, smalltalk.IRJSTranslator)})}, args: ["anIRDynamicDictionary"], source: "visitIRDynamicDictionary: anIRDynamicDictionary\x0a\x09self stream nextPutAll: 'smalltalk.HashedCollection._fromPairs_(['.\x0a\x09\x09anIRDynamicDictionary instructions \x0a\x09\x09\x09do: [ :each | self visit: each ]\x0a\x09\x09\x09separatedBy: [self stream nextPutAll: ',' ].\x0a\x09self stream nextPutAll: '])'", messageSends: ["nextPutAll:", "stream", "do:separatedBy:", "visit:", "instructions"], referencedClasses: [] }), smalltalk.IRJSTranslator); smalltalk.addMethod( "_visitIRMethod_", smalltalk.method({ selector: "visitIRMethod:", category: 'visiting', fn: function (anIRMethod){ var self=this; return smalltalk.withContext(function($ctx1) { var $1,$2; _st(_st(self)._stream())._nextPutMethodDeclaration_with_(anIRMethod,(function(){ return smalltalk.withContext(function($ctx2) { return _st(_st(self)._stream())._nextPutFunctionWith_arguments_((function(){ return smalltalk.withContext(function($ctx3) { _st(_st(self)._stream())._nextPutVars_(_st(_st(anIRMethod)._tempDeclarations())._collect_((function(each){ return smalltalk.withContext(function($ctx4) { return _st(_st(each)._name())._asVariableName(); }, function($ctx4) {$ctx4.fillBlock({each:each},$ctx1)})}))); return _st(_st(self)._stream())._nextPutContextFor_during_(anIRMethod,(function(){ return smalltalk.withContext(function($ctx4) { $1=_st(_st(anIRMethod)._internalVariables())._notEmpty(); if(smalltalk.assert($1)){ _st(_st(self)._stream())._nextPutVars_(_st(_st(_st(anIRMethod)._internalVariables())._asArray())._collect_((function(each){ return smalltalk.withContext(function($ctx5) { return _st(_st(each)._variable())._alias(); }, function($ctx5) {$ctx5.fillBlock({each:each},$ctx1)})}))); }; $2=_st(_st(anIRMethod)._scope())._hasNonLocalReturn(); if(smalltalk.assert($2)){ return _st(_st(self)._stream())._nextPutNonLocalReturnHandlingWith_((function(){ return smalltalk.withContext(function($ctx5) { return smalltalk.IRVisitor.fn.prototype._visitIRMethod_.apply(_st(self), [anIRMethod]); }, function($ctx5) {$ctx5.fillBlock({},$ctx1)})})); } else { return smalltalk.IRVisitor.fn.prototype._visitIRMethod_.apply(_st(self), [anIRMethod]); }; }, function($ctx4) {$ctx4.fillBlock({},$ctx1)})})); }, function($ctx3) {$ctx3.fillBlock({},$ctx1)})}),_st(anIRMethod)._arguments()); }, function($ctx2) {$ctx2.fillBlock({},$ctx1)})})); return self}, function($ctx1) {$ctx1.fill(self,"visitIRMethod:",{anIRMethod:anIRMethod}, smalltalk.IRJSTranslator)})}, args: ["anIRMethod"], source: "visitIRMethod: anIRMethod\x0a\x0a\x09self stream\x0a\x09\x09nextPutMethodDeclaration: anIRMethod \x0a\x09\x09with: [ self stream \x0a\x09\x09\x09nextPutFunctionWith: [ \x0a \x09self stream nextPutVars: (anIRMethod tempDeclarations collect: [ :each |\x0a \x09\x09\x09\x09each name asVariableName ]).\x0a \x09self stream nextPutContextFor: anIRMethod during: [\x0a\x09\x09\x09\x09anIRMethod internalVariables notEmpty ifTrue: [\x0a\x09\x09\x09\x09\x09self stream nextPutVars: (anIRMethod internalVariables asArray collect: [ :each |\x0a\x09\x09\x09\x09\x09\x09each variable alias ]) ].\x0a\x09\x09\x09\x09anIRMethod scope hasNonLocalReturn \x0a\x09\x09\x09\x09\x09ifTrue: [\x0a\x09\x09\x09\x09\x09\x09self stream nextPutNonLocalReturnHandlingWith: [\x0a\x09\x09\x09\x09\x09\x09\x09super visitIRMethod: anIRMethod ]]\x0a\x09\x09\x09\x09\x09ifFalse: [ super visitIRMethod: anIRMethod ]]]\x0a\x09\x09\x09arguments: anIRMethod arguments ]", messageSends: ["nextPutMethodDeclaration:with:", "nextPutFunctionWith:arguments:", "nextPutVars:", "collect:", "asVariableName", "name", "tempDeclarations", "stream", "nextPutContextFor:during:", "ifTrue:", "alias", "variable", "asArray", "internalVariables", "notEmpty", "ifTrue:ifFalse:", "nextPutNonLocalReturnHandlingWith:", "visitIRMethod:", "hasNonLocalReturn", "scope", "arguments"], referencedClasses: [] }), smalltalk.IRJSTranslator); smalltalk.addMethod( "_visitIRNonLocalReturn_", smalltalk.method({ selector: "visitIRNonLocalReturn:", category: 'visiting', fn: function (anIRNonLocalReturn){ var self=this; return smalltalk.withContext(function($ctx1) { _st(_st(self)._stream())._nextPutNonLocalReturnWith_((function(){ return smalltalk.withContext(function($ctx2) { return smalltalk.IRVisitor.fn.prototype._visitIRNonLocalReturn_.apply(_st(self), [anIRNonLocalReturn]); }, function($ctx2) {$ctx2.fillBlock({},$ctx1)})})); return self}, function($ctx1) {$ctx1.fill(self,"visitIRNonLocalReturn:",{anIRNonLocalReturn:anIRNonLocalReturn}, smalltalk.IRJSTranslator)})}, args: ["anIRNonLocalReturn"], source: "visitIRNonLocalReturn: anIRNonLocalReturn\x0a\x09self stream nextPutNonLocalReturnWith: [\x0a\x09\x09super visitIRNonLocalReturn: anIRNonLocalReturn ]", messageSends: ["nextPutNonLocalReturnWith:", "visitIRNonLocalReturn:", "stream"], referencedClasses: [] }), smalltalk.IRJSTranslator); smalltalk.addMethod( "_visitIRReturn_", smalltalk.method({ selector: "visitIRReturn:", category: 'visiting', fn: function (anIRReturn){ var self=this; return smalltalk.withContext(function($ctx1) { _st(_st(self)._stream())._nextPutReturnWith_((function(){ return smalltalk.withContext(function($ctx2) { return smalltalk.IRVisitor.fn.prototype._visitIRReturn_.apply(_st(self), [anIRReturn]); }, function($ctx2) {$ctx2.fillBlock({},$ctx1)})})); return self}, function($ctx1) {$ctx1.fill(self,"visitIRReturn:",{anIRReturn:anIRReturn}, smalltalk.IRJSTranslator)})}, args: ["anIRReturn"], source: "visitIRReturn: anIRReturn\x0a\x09self stream nextPutReturnWith: [\x0a\x09\x09super visitIRReturn: anIRReturn ]", messageSends: ["nextPutReturnWith:", "visitIRReturn:", "stream"], referencedClasses: [] }), smalltalk.IRJSTranslator); smalltalk.addMethod( "_visitIRSend_", smalltalk.method({ selector: "visitIRSend:", category: 'visiting', fn: function (anIRSend){ var self=this; return smalltalk.withContext(function($ctx1) { var $1,$2,$3; $1=_st(anIRSend)._classSend(); if(($receiver = $1) == nil || $receiver == undefined){ _st(_st(self)._stream())._nextPutAll_("_st("); _st(self)._visit_(_st(_st(anIRSend)._instructions())._first()); _st(_st(self)._stream())._nextPutAll_(_st(_st(").").__comma(_st(_st(anIRSend)._selector())._asSelector())).__comma("(")); _st(_st(_st(anIRSend)._instructions())._allButFirst())._do_separatedBy_((function(each){ return smalltalk.withContext(function($ctx2) { return _st(self)._visit_(each); }, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1)})}),(function(){ return smalltalk.withContext(function($ctx2) { return _st(_st(self)._stream())._nextPutAll_(","); }, function($ctx2) {$ctx2.fillBlock({},$ctx1)})})); _st(_st(self)._stream())._nextPutAll_(")"); } else { $2=_st(self)._stream(); _st($2)._nextPutAll_(_st(_st(_st(anIRSend)._classSend())._asJavascript()).__comma(".fn.prototype.")); _st($2)._nextPutAll_(_st(_st(_st(anIRSend)._selector())._asSelector()).__comma(".apply(")); $3=_st($2)._nextPutAll_("_st("); $3; _st(self)._visit_(_st(_st(anIRSend)._instructions())._first()); _st(_st(self)._stream())._nextPutAll_("), ["); _st(_st(_st(anIRSend)._instructions())._allButFirst())._do_separatedBy_((function(each){ return smalltalk.withContext(function($ctx2) { return _st(self)._visit_(each); }, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1)})}),(function(){ return smalltalk.withContext(function($ctx2) { return _st(_st(self)._stream())._nextPutAll_(","); }, function($ctx2) {$ctx2.fillBlock({},$ctx1)})})); _st(_st(self)._stream())._nextPutAll_("])"); }; return self}, function($ctx1) {$ctx1.fill(self,"visitIRSend:",{anIRSend:anIRSend}, smalltalk.IRJSTranslator)})}, args: ["anIRSend"], source: "visitIRSend: anIRSend\x0a\x09anIRSend classSend \x0a \x09ifNil: [\x0a\x09\x09\x09self stream nextPutAll: '_st('.\x0a\x09\x09\x09self visit: anIRSend instructions first.\x0a \x09\x09 \x09self stream nextPutAll: ').', anIRSend selector asSelector, '('.\x0a\x09\x09\x09anIRSend instructions allButFirst\x0a\x09\x09\x09\x09do: [ :each | self visit: each ]\x0a\x09\x09\x09\x09separatedBy: [ self stream nextPutAll: ',' ].\x0a\x09\x09\x09self stream nextPutAll: ')' ]\x0a\x09\x09ifNotNil: [ \x0a\x09\x09\x09self stream \x0a \x09nextPutAll: anIRSend classSend asJavascript, '.fn.prototype.';\x0a\x09\x09\x09\x09nextPutAll: anIRSend selector asSelector, '.apply(';\x0a\x09\x09\x09\x09nextPutAll: '_st('.\x0a\x09\x09\x09self visit: anIRSend instructions first.\x0a\x09\x09\x09self stream nextPutAll: '), ['.\x0a\x09\x09\x09anIRSend instructions allButFirst\x0a\x09\x09\x09\x09do: [ :each | self visit: each ]\x0a\x09\x09\x09\x09separatedBy: [ self stream nextPutAll: ',' ].\x0a\x09\x09\x09self stream nextPutAll: '])' ]", messageSends: ["ifNil:ifNotNil:", "nextPutAll:", "stream", "visit:", "first", "instructions", ",", "asSelector", "selector", "do:separatedBy:", "allButFirst", "asJavascript", "classSend"], referencedClasses: [] }), smalltalk.IRJSTranslator); smalltalk.addMethod( "_visitIRSequence_", smalltalk.method({ selector: "visitIRSequence:", category: 'visiting', fn: function (anIRSequence){ var self=this; return smalltalk.withContext(function($ctx1) { _st(_st(self)._stream())._nextPutSequenceWith_((function(){ return smalltalk.withContext(function($ctx2) { return _st(_st(anIRSequence)._instructions())._do_((function(each){ return smalltalk.withContext(function($ctx3) { return _st(_st(self)._stream())._nextPutStatementWith_(_st(self)._visit_(each)); }, function($ctx3) {$ctx3.fillBlock({each:each},$ctx1)})})); }, function($ctx2) {$ctx2.fillBlock({},$ctx1)})})); return self}, function($ctx1) {$ctx1.fill(self,"visitIRSequence:",{anIRSequence:anIRSequence}, smalltalk.IRJSTranslator)})}, args: ["anIRSequence"], source: "visitIRSequence: anIRSequence\x0a\x09self stream nextPutSequenceWith: [\x0a\x09\x09anIRSequence instructions do: [ :each |\x0a\x09\x09\x09self stream nextPutStatementWith: (self visit: each) ]]", messageSends: ["nextPutSequenceWith:", "do:", "nextPutStatementWith:", "visit:", "stream", "instructions"], referencedClasses: [] }), smalltalk.IRJSTranslator); smalltalk.addMethod( "_visitIRTempDeclaration_", smalltalk.method({ selector: "visitIRTempDeclaration:", category: 'visiting', fn: function (anIRTempDeclaration){ var self=this; return smalltalk.withContext(function($ctx1) { return self}, function($ctx1) {$ctx1.fill(self,"visitIRTempDeclaration:",{anIRTempDeclaration:anIRTempDeclaration}, smalltalk.IRJSTranslator)})}, args: ["anIRTempDeclaration"], source: "visitIRTempDeclaration: anIRTempDeclaration\x0a\x09\x22self stream \x0a \x09nextPutAll: 'var ', anIRTempDeclaration name asVariableName, ';'; \x0a lf\x22", messageSends: [], referencedClasses: [] }), smalltalk.IRJSTranslator); smalltalk.addMethod( "_visitIRValue_", smalltalk.method({ selector: "visitIRValue:", category: 'visiting', fn: function (anIRValue){ var self=this; return smalltalk.withContext(function($ctx1) { _st(_st(self)._stream())._nextPutAll_(_st(_st(anIRValue)._value())._asJavascript()); return self}, function($ctx1) {$ctx1.fill(self,"visitIRValue:",{anIRValue:anIRValue}, smalltalk.IRJSTranslator)})}, args: ["anIRValue"], source: "visitIRValue: anIRValue\x0a\x09self stream nextPutAll: anIRValue value asJavascript", messageSends: ["nextPutAll:", "asJavascript", "value", "stream"], referencedClasses: [] }), smalltalk.IRJSTranslator); smalltalk.addMethod( "_visitIRVariable_", smalltalk.method({ selector: "visitIRVariable:", category: 'visiting', fn: function (anIRVariable){ var self=this; return smalltalk.withContext(function($ctx1) { var $1; $1=_st(_st(_st(anIRVariable)._variable())._name()).__eq("thisContext"); if(smalltalk.assert($1)){ _st(_st(self)._stream())._nextPutAll_("smalltalk.getThisContext()"); } else { _st(_st(self)._stream())._nextPutAll_(_st(_st(anIRVariable)._variable())._alias()); }; return self}, function($ctx1) {$ctx1.fill(self,"visitIRVariable:",{anIRVariable:anIRVariable}, smalltalk.IRJSTranslator)})}, args: ["anIRVariable"], source: "visitIRVariable: anIRVariable\x0a\x09anIRVariable variable name = 'thisContext'\x0a \x09ifTrue: [ self stream nextPutAll: 'smalltalk.getThisContext()' ]\x0a \x09ifFalse: [ self stream nextPutAll: anIRVariable variable alias ]", messageSends: ["ifTrue:ifFalse:", "nextPutAll:", "stream", "alias", "variable", "=", "name"], referencedClasses: [] }), smalltalk.IRJSTranslator); smalltalk.addMethod( "_visitIRVerbatim_", smalltalk.method({ selector: "visitIRVerbatim:", category: 'visiting', fn: function (anIRVerbatim){ var self=this; return smalltalk.withContext(function($ctx1) { _st(_st(self)._stream())._nextPutStatementWith_((function(){ return smalltalk.withContext(function($ctx2) { return _st(_st(self)._stream())._nextPutAll_(_st(anIRVerbatim)._source()); }, function($ctx2) {$ctx2.fillBlock({},$ctx1)})})); return self}, function($ctx1) {$ctx1.fill(self,"visitIRVerbatim:",{anIRVerbatim:anIRVerbatim}, smalltalk.IRJSTranslator)})}, args: ["anIRVerbatim"], source: "visitIRVerbatim: anIRVerbatim\x0a\x09self stream nextPutStatementWith: [\x0a\x09\x09self stream nextPutAll: anIRVerbatim source ]", messageSends: ["nextPutStatementWith:", "nextPutAll:", "source", "stream"], referencedClasses: [] }), smalltalk.IRJSTranslator); smalltalk.addClass('JSStream', smalltalk.Object, ['stream'], 'Compiler-IR'); smalltalk.addMethod( "_contents", smalltalk.method({ selector: "contents", category: 'accessing', fn: function (){ var self=this; return smalltalk.withContext(function($ctx1) { var $1; $1=_st(self["@stream"])._contents(); return $1; }, function($ctx1) {$ctx1.fill(self,"contents",{}, smalltalk.JSStream)})}, args: [], source: "contents\x0a\x09^ stream contents", messageSends: ["contents"], referencedClasses: [] }), smalltalk.JSStream); smalltalk.addMethod( "_initialize", smalltalk.method({ selector: "initialize", category: 'initialization', fn: function (){ var self=this; return smalltalk.withContext(function($ctx1) { smalltalk.Object.fn.prototype._initialize.apply(_st(self), []); self["@stream"]=_st("")._writeStream(); return self}, function($ctx1) {$ctx1.fill(self,"initialize",{}, smalltalk.JSStream)})}, args: [], source: "initialize\x0a\x09super initialize.\x0a\x09stream := '' writeStream.", messageSends: ["initialize", "writeStream"], referencedClasses: [] }), smalltalk.JSStream); smalltalk.addMethod( "_lf", smalltalk.method({ selector: "lf", category: 'streaming', fn: function (){ var self=this; return smalltalk.withContext(function($ctx1) { _st(self["@stream"])._lf(); return self}, function($ctx1) {$ctx1.fill(self,"lf",{}, smalltalk.JSStream)})}, args: [], source: "lf\x0a\x09stream lf", messageSends: ["lf"], referencedClasses: [] }), smalltalk.JSStream); smalltalk.addMethod( "_nextPut_", smalltalk.method({ selector: "nextPut:", category: 'streaming', fn: function (aString){ var self=this; return smalltalk.withContext(function($ctx1) { _st(self["@stream"])._nextPut_(aString); return self}, function($ctx1) {$ctx1.fill(self,"nextPut:",{aString:aString}, smalltalk.JSStream)})}, args: ["aString"], source: "nextPut: aString\x0a\x09stream nextPut: aString", messageSends: ["nextPut:"], referencedClasses: [] }), smalltalk.JSStream); smalltalk.addMethod( "_nextPutAll_", smalltalk.method({ selector: "nextPutAll:", category: 'streaming', fn: function (aString){ var self=this; return smalltalk.withContext(function($ctx1) { _st(self["@stream"])._nextPutAll_(aString); return self}, function($ctx1) {$ctx1.fill(self,"nextPutAll:",{aString:aString}, smalltalk.JSStream)})}, args: ["aString"], source: "nextPutAll: aString\x0a\x09stream nextPutAll: aString", messageSends: ["nextPutAll:"], referencedClasses: [] }), smalltalk.JSStream); smalltalk.addMethod( "_nextPutAssignment", smalltalk.method({ selector: "nextPutAssignment", category: 'streaming', fn: function (){ var self=this; return smalltalk.withContext(function($ctx1) { _st(self["@stream"])._nextPutAll_("="); return self}, function($ctx1) {$ctx1.fill(self,"nextPutAssignment",{}, smalltalk.JSStream)})}, args: [], source: "nextPutAssignment\x0a\x09stream nextPutAll: '='", messageSends: ["nextPutAll:"], referencedClasses: [] }), smalltalk.JSStream); smalltalk.addMethod( "_nextPutBlockContextFor_during_", smalltalk.method({ selector: "nextPutBlockContextFor:during:", category: 'streaming', fn: function (anIRClosure,aBlock){ var self=this; return smalltalk.withContext(function($ctx1) { var $1,$2,$3,$4,$5,$6,$7,$8; $1=self; _st($1)._nextPutAll_(_st(_st("return smalltalk.withContext(function(").__comma(_st(_st(anIRClosure)._scope())._alias())).__comma(") {")); $2=_st($1)._nextPutAll_(_st((smalltalk.String || String))._cr()); _st(aBlock)._value(); $3=self; _st($3)._nextPutAll_(_st(_st("}, function(").__comma(_st(_st(anIRClosure)._scope())._alias())).__comma(") {")); $4=_st($3)._nextPutAll_(_st(_st(_st(anIRClosure)._scope())._alias()).__comma(".fillBlock({")); _st(_st(anIRClosure)._locals())._do_separatedBy_((function(each){ return smalltalk.withContext(function($ctx2) { $5=self; _st($5)._nextPutAll_(_st(each)._asVariableName()); _st($5)._nextPutAll_(":"); $6=_st($5)._nextPutAll_(_st(each)._asVariableName()); return $6; }, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1)})}),(function(){ return smalltalk.withContext(function($ctx2) { return _st(self)._nextPutAll_(","); }, function($ctx2) {$ctx2.fillBlock({},$ctx1)})})); $7=self; _st($7)._nextPutAll_("},"); $8=_st($7)._nextPutAll_(_st(_st(_st(_st(anIRClosure)._method())._scope())._alias()).__comma(")})")); return self}, function($ctx1) {$ctx1.fill(self,"nextPutBlockContextFor:during:",{anIRClosure:anIRClosure,aBlock:aBlock}, smalltalk.JSStream)})}, args: ["anIRClosure", "aBlock"], source: "nextPutBlockContextFor: anIRClosure during: aBlock\x0a\x09self \x0a \x09nextPutAll: 'return smalltalk.withContext(function(', anIRClosure scope alias, ') {'; \x0a nextPutAll: String cr.\x0a \x0a aBlock value.\x0a \x0a self \x0a \x09nextPutAll: '}, function(', anIRClosure scope alias, ') {';\x0a nextPutAll: anIRClosure scope alias, '.fillBlock({'.\x0a \x0a anIRClosure locals \x0a \x09do: [ :each |\x0a \x09\x09self \x0a \x09\x09nextPutAll: each asVariableName;\x0a \x09 \x09nextPutAll: ':';\x0a \x09\x09nextPutAll: each asVariableName]\x0a\x09\x09separatedBy: [ self nextPutAll: ',' ].\x0a \x0a self\x0a \x09nextPutAll: '},';\x0a nextPutAll: anIRClosure method scope alias, ')})'", messageSends: ["nextPutAll:", ",", "alias", "scope", "cr", "value", "do:separatedBy:", "asVariableName", "locals", "method"], referencedClasses: ["String"] }), smalltalk.JSStream); smalltalk.addMethod( "_nextPutClosureWith_arguments_", smalltalk.method({ selector: "nextPutClosureWith:arguments:", category: 'streaming', fn: function (aBlock,anArray){ var self=this; return smalltalk.withContext(function($ctx1) { var $1,$2; _st(self["@stream"])._nextPutAll_("(function("); _st(anArray)._do_separatedBy_((function(each){ return smalltalk.withContext(function($ctx2) { return _st(self["@stream"])._nextPutAll_(_st(each)._asVariableName()); }, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1)})}),(function(){ return smalltalk.withContext(function($ctx2) { return _st(self["@stream"])._nextPut_(","); }, function($ctx2) {$ctx2.fillBlock({},$ctx1)})})); $1=self["@stream"]; _st($1)._nextPutAll_("){"); $2=_st($1)._lf(); _st(aBlock)._value(); _st(self["@stream"])._nextPutAll_("})"); return self}, function($ctx1) {$ctx1.fill(self,"nextPutClosureWith:arguments:",{aBlock:aBlock,anArray:anArray}, smalltalk.JSStream)})}, args: ["aBlock", "anArray"], source: "nextPutClosureWith: aBlock arguments: anArray\x0a\x09stream nextPutAll: '(function('.\x0a\x09anArray \x0a\x09\x09do: [ :each | stream nextPutAll: each asVariableName ]\x0a\x09\x09separatedBy: [ stream nextPut: ',' ].\x0a\x09stream nextPutAll: '){'; lf.\x0a\x09aBlock value.\x0a\x09stream nextPutAll: '})'", messageSends: ["nextPutAll:", "do:separatedBy:", "asVariableName", "nextPut:", "lf", "value"], referencedClasses: [] }), smalltalk.JSStream); smalltalk.addMethod( "_nextPutContextFor_during_", smalltalk.method({ selector: "nextPutContextFor:during:", category: 'streaming', fn: function (aMethod,aBlock){ var self=this; return smalltalk.withContext(function($ctx1) { var $1,$2,$3,$4,$5,$6,$7,$8; $1=self; _st($1)._nextPutAll_(_st(_st("return smalltalk.withContext(function(").__comma(_st(_st(aMethod)._scope())._alias())).__comma(") { ")); $2=_st($1)._nextPutAll_(_st((smalltalk.String || String))._cr()); _st(aBlock)._value(); $3=self; _st($3)._nextPutAll_(_st(_st(_st("}, function(").__comma(_st(_st(aMethod)._scope())._alias())).__comma(") {")).__comma(_st(_st(aMethod)._scope())._alias())); $4=_st($3)._nextPutAll_(_st(_st(".fill(self,").__comma(_st(_st(aMethod)._selector())._asJavascript())).__comma(",{")); _st(_st(aMethod)._locals())._do_separatedBy_((function(each){ return smalltalk.withContext(function($ctx2) { $5=self; _st($5)._nextPutAll_(_st(each)._asVariableName()); _st($5)._nextPutAll_(":"); $6=_st($5)._nextPutAll_(_st(each)._asVariableName()); return $6; }, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1)})}),(function(){ return smalltalk.withContext(function($ctx2) { return _st(self)._nextPutAll_(","); }, function($ctx2) {$ctx2.fillBlock({},$ctx1)})})); $7=self; _st($7)._nextPutAll_("}, "); _st($7)._nextPutAll_(_st(_st(aMethod)._theClass())._asJavascript()); $8=_st($7)._nextPutAll_(")})"); return self}, function($ctx1) {$ctx1.fill(self,"nextPutContextFor:during:",{aMethod:aMethod,aBlock:aBlock}, smalltalk.JSStream)})}, args: ["aMethod", "aBlock"], source: "nextPutContextFor: aMethod during: aBlock\x0a\x09self \x0a \x09nextPutAll: 'return smalltalk.withContext(function(', aMethod scope alias, ') { '; \x0a nextPutAll: String cr.\x0a aBlock value.\x0a \x0a self \x0a \x09nextPutAll: '}, function(', aMethod scope alias, ') {', aMethod scope alias; \x0a nextPutAll: '.fill(self,', aMethod selector asJavascript, ',{'.\x0a\x0a aMethod locals \x0a \x09do: [ :each |\x0a \x09\x09self \x0a \x09\x09nextPutAll: each asVariableName;\x0a \x09 \x09nextPutAll: ':';\x0a \x09\x09nextPutAll: each asVariableName]\x0a\x09\x09separatedBy: [ self nextPutAll: ',' ].\x0a \x0a self\x0a \x09nextPutAll: '}, ';\x0a nextPutAll: aMethod theClass asJavascript;\x0a nextPutAll: ')})'", messageSends: ["nextPutAll:", ",", "alias", "scope", "cr", "value", "asJavascript", "selector", "do:separatedBy:", "asVariableName", "locals", "theClass"], referencedClasses: ["String"] }), smalltalk.JSStream); smalltalk.addMethod( "_nextPutFunctionWith_arguments_", smalltalk.method({ selector: "nextPutFunctionWith:arguments:", category: 'streaming', fn: function (aBlock,anArray){ var self=this; return smalltalk.withContext(function($ctx1) { var $1,$2,$3,$4; _st(self["@stream"])._nextPutAll_("fn: function("); _st(anArray)._do_separatedBy_((function(each){ return smalltalk.withContext(function($ctx2) { return _st(self["@stream"])._nextPutAll_(_st(each)._asVariableName()); }, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1)})}),(function(){ return smalltalk.withContext(function($ctx2) { return _st(self["@stream"])._nextPut_(","); }, function($ctx2) {$ctx2.fillBlock({},$ctx1)})})); $1=self["@stream"]; _st($1)._nextPutAll_("){"); $2=_st($1)._lf(); $3=self["@stream"]; _st($3)._nextPutAll_("var self=this;"); $4=_st($3)._lf(); _st(aBlock)._value(); _st(self["@stream"])._nextPutAll_("}"); return self}, function($ctx1) {$ctx1.fill(self,"nextPutFunctionWith:arguments:",{aBlock:aBlock,anArray:anArray}, smalltalk.JSStream)})}, args: ["aBlock", "anArray"], source: "nextPutFunctionWith: aBlock arguments: anArray\x0a\x09stream nextPutAll: 'fn: function('.\x0a\x09anArray \x0a\x09\x09do: [ :each | stream nextPutAll: each asVariableName ]\x0a\x09\x09separatedBy: [ stream nextPut: ',' ].\x0a\x09stream nextPutAll: '){'; lf.\x0a\x09stream nextPutAll: 'var self=this;'; lf.\x0a\x09aBlock value.\x0a\x09stream nextPutAll: '}'", messageSends: ["nextPutAll:", "do:separatedBy:", "asVariableName", "nextPut:", "lf", "value"], referencedClasses: [] }), smalltalk.JSStream); smalltalk.addMethod( "_nextPutIf_with_", smalltalk.method({ selector: "nextPutIf:with:", category: 'streaming', fn: function (aBlock,anotherBlock){ var self=this; return smalltalk.withContext(function($ctx1) { var $1,$2; _st(self["@stream"])._nextPutAll_("if("); _st(aBlock)._value(); $1=self["@stream"]; _st($1)._nextPutAll_("){"); $2=_st($1)._lf(); _st(anotherBlock)._value(); _st(self["@stream"])._nextPutAll_("}"); return self}, function($ctx1) {$ctx1.fill(self,"nextPutIf:with:",{aBlock:aBlock,anotherBlock:anotherBlock}, smalltalk.JSStream)})}, args: ["aBlock", "anotherBlock"], source: "nextPutIf: aBlock with: anotherBlock\x0a\x09stream nextPutAll: 'if('.\x0a\x09aBlock value.\x0a\x09stream nextPutAll: '){'; lf.\x0a\x09anotherBlock value.\x0a\x09stream nextPutAll: '}'", messageSends: ["nextPutAll:", "value", "lf"], referencedClasses: [] }), smalltalk.JSStream); smalltalk.addMethod( "_nextPutIfElse_with_with_", smalltalk.method({ selector: "nextPutIfElse:with:with:", category: 'streaming', fn: function (aBlock,ifBlock,elseBlock){ var self=this; return smalltalk.withContext(function($ctx1) { var $1,$2,$3,$4; _st(self["@stream"])._nextPutAll_("if("); _st(aBlock)._value(); $1=self["@stream"]; _st($1)._nextPutAll_("){"); $2=_st($1)._lf(); _st(ifBlock)._value(); $3=self["@stream"]; _st($3)._nextPutAll_("} else {"); $4=_st($3)._lf(); _st(elseBlock)._value(); _st(self["@stream"])._nextPutAll_("}"); return self}, function($ctx1) {$ctx1.fill(self,"nextPutIfElse:with:with:",{aBlock:aBlock,ifBlock:ifBlock,elseBlock:elseBlock}, smalltalk.JSStream)})}, args: ["aBlock", "ifBlock", "elseBlock"], source: "nextPutIfElse: aBlock with: ifBlock with: elseBlock\x0a\x09stream nextPutAll: 'if('.\x0a\x09aBlock value.\x0a\x09stream nextPutAll: '){'; lf.\x0a\x09ifBlock value.\x0a\x09stream nextPutAll: '} else {'; lf.\x0a\x09elseBlock value.\x0a\x09stream nextPutAll: '}'", messageSends: ["nextPutAll:", "value", "lf"], referencedClasses: [] }), smalltalk.JSStream); smalltalk.addMethod( "_nextPutMethodDeclaration_with_", smalltalk.method({ selector: "nextPutMethodDeclaration:with:", category: 'streaming', fn: function (aMethod,aBlock){ var self=this; return smalltalk.withContext(function($ctx1) { var $1,$2,$3,$4,$5,$6; $1=self["@stream"]; _st($1)._nextPutAll_("smalltalk.method({"); _st($1)._lf(); _st($1)._nextPutAll_(_st(_st("selector: \x22").__comma(_st(aMethod)._selector())).__comma("\x22,")); _st($1)._lf(); _st($1)._nextPutAll_(_st(_st("source: ").__comma(_st(_st(aMethod)._source())._asJavascript())).__comma(",")); $2=_st($1)._lf(); _st(aBlock)._value(); $3=self["@stream"]; _st($3)._nextPutAll_(_st(_st(",").__comma(_st((smalltalk.String || String))._lf())).__comma("messageSends: ")); _st($3)._nextPutAll_(_st(_st(_st(_st(aMethod)._messageSends())._asArray())._asJavascript()).__comma(",")); _st($3)._lf(); _st($3)._nextPutAll_(_st(_st("args: ").__comma(_st(_st(_st(_st(aMethod)._arguments())._collect_((function(each){ return smalltalk.withContext(function($ctx2) { return _st(each)._value(); }, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1)})})))._asArray())._asJavascript())).__comma(",")); _st($3)._lf(); $4=_st($3)._nextPutAll_("referencedClasses: ["); _st(_st(aMethod)._classReferences())._do_separatedBy_((function(each){ return smalltalk.withContext(function($ctx2) { return _st(self["@stream"])._nextPutAll_(_st(each)._asJavascript()); }, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1)})}),(function(){ return smalltalk.withContext(function($ctx2) { return _st(self["@stream"])._nextPutAll_(","); }, function($ctx2) {$ctx2.fillBlock({},$ctx1)})})); $5=self["@stream"]; _st($5)._nextPutAll_("]"); $6=_st($5)._nextPutAll_("})"); return self}, function($ctx1) {$ctx1.fill(self,"nextPutMethodDeclaration:with:",{aMethod:aMethod,aBlock:aBlock}, smalltalk.JSStream)})}, args: ["aMethod", "aBlock"], source: "nextPutMethodDeclaration: aMethod with: aBlock\x0a\x09stream \x0a\x09\x09nextPutAll: 'smalltalk.method({'; lf;\x0a\x09\x09nextPutAll: 'selector: \x22', aMethod selector, '\x22,'; lf;\x0a\x09\x09nextPutAll: 'source: ', aMethod source asJavascript, ',';lf. \x0a\x09aBlock value.\x0a\x09stream \x0a\x09\x09nextPutAll: ',', String lf, 'messageSends: ';\x0a\x09\x09nextPutAll: aMethod messageSends asArray asJavascript, ','; lf;\x0a nextPutAll: 'args: ', (aMethod arguments collect: [ :each | each value ]) asArray asJavascript, ','; lf;\x0a\x09\x09nextPutAll: 'referencedClasses: ['.\x0a\x09aMethod classReferences \x0a\x09\x09do: [:each | stream nextPutAll: each asJavascript]\x0a\x09\x09separatedBy: [stream nextPutAll: ','].\x0a\x09stream \x0a\x09\x09nextPutAll: ']';\x0a\x09\x09nextPutAll: '})'", messageSends: ["nextPutAll:", "lf", ",", "selector", "asJavascript", "source", "value", "asArray", "messageSends", "collect:", "arguments", "do:separatedBy:", "classReferences"], referencedClasses: ["String"] }), smalltalk.JSStream); smalltalk.addMethod( "_nextPutNonLocalReturnHandlingWith_", smalltalk.method({ selector: "nextPutNonLocalReturnHandlingWith:", category: 'streaming', fn: function (aBlock){ var self=this; return smalltalk.withContext(function($ctx1) { var $1,$2,$3,$4; $1=self["@stream"]; _st($1)._nextPutAll_("var $early={};"); _st($1)._lf(); _st($1)._nextPutAll_("try {"); $2=_st($1)._lf(); _st(aBlock)._value(); $3=self["@stream"]; _st($3)._nextPutAll_("}"); _st($3)._lf(); _st($3)._nextPutAll_("catch(e) {if(e===$early)return e[0]; throw e}"); $4=_st($3)._lf(); return self}, function($ctx1) {$ctx1.fill(self,"nextPutNonLocalReturnHandlingWith:",{aBlock:aBlock}, smalltalk.JSStream)})}, args: ["aBlock"], source: "nextPutNonLocalReturnHandlingWith: aBlock\x0a\x09stream \x0a\x09\x09nextPutAll: 'var $early={};'; lf;\x0a\x09\x09nextPutAll: 'try {'; lf.\x0a\x09aBlock value.\x0a\x09stream \x0a\x09\x09nextPutAll: '}'; lf;\x0a\x09\x09nextPutAll: 'catch(e) {if(e===$early)return e[0]; throw e}'; lf", messageSends: ["nextPutAll:", "lf", "value"], referencedClasses: [] }), smalltalk.JSStream); smalltalk.addMethod( "_nextPutNonLocalReturnWith_", smalltalk.method({ selector: "nextPutNonLocalReturnWith:", category: 'streaming', fn: function (aBlock){ var self=this; return smalltalk.withContext(function($ctx1) { _st(self["@stream"])._nextPutAll_("throw $early=["); _st(aBlock)._value(); _st(self["@stream"])._nextPutAll_("]"); return self}, function($ctx1) {$ctx1.fill(self,"nextPutNonLocalReturnWith:",{aBlock:aBlock}, smalltalk.JSStream)})}, args: ["aBlock"], source: "nextPutNonLocalReturnWith: aBlock\x0a\x09stream nextPutAll: 'throw $early=['.\x0a\x09aBlock value.\x0a\x09stream nextPutAll: ']'", messageSends: ["nextPutAll:", "value"], referencedClasses: [] }), smalltalk.JSStream); smalltalk.addMethod( "_nextPutReturn", smalltalk.method({ selector: "nextPutReturn", category: 'streaming', fn: function (){ var self=this; return smalltalk.withContext(function($ctx1) { _st(self["@stream"])._nextPutAll_("return "); return self}, function($ctx1) {$ctx1.fill(self,"nextPutReturn",{}, smalltalk.JSStream)})}, args: [], source: "nextPutReturn\x0a\x09stream nextPutAll: 'return '", messageSends: ["nextPutAll:"], referencedClasses: [] }), smalltalk.JSStream); smalltalk.addMethod( "_nextPutReturnWith_", smalltalk.method({ selector: "nextPutReturnWith:", category: 'streaming', fn: function (aBlock){ var self=this; return smalltalk.withContext(function($ctx1) { _st(self)._nextPutReturn(); _st(aBlock)._value(); return self}, function($ctx1) {$ctx1.fill(self,"nextPutReturnWith:",{aBlock:aBlock}, smalltalk.JSStream)})}, args: ["aBlock"], source: "nextPutReturnWith: aBlock\x0a\x09self nextPutReturn.\x0a\x09aBlock value", messageSends: ["nextPutReturn", "value"], referencedClasses: [] }), smalltalk.JSStream); smalltalk.addMethod( "_nextPutSequenceWith_", smalltalk.method({ selector: "nextPutSequenceWith:", category: 'streaming', fn: function (aBlock){ var self=this; return smalltalk.withContext(function($ctx1) { _st(aBlock)._value(); return self}, function($ctx1) {$ctx1.fill(self,"nextPutSequenceWith:",{aBlock:aBlock}, smalltalk.JSStream)})}, args: ["aBlock"], source: "nextPutSequenceWith: aBlock\x0a\x09\x22stream \x0a\x09\x09nextPutAll: 'switch(smalltalk.thisContext.pc){'; lf.\x22\x0a\x09aBlock value.\x0a\x09\x22stream \x0a\x09\x09nextPutAll: '};'; lf\x22", messageSends: ["value"], referencedClasses: [] }), smalltalk.JSStream); smalltalk.addMethod( "_nextPutStatement_with_", smalltalk.method({ selector: "nextPutStatement:with:", category: 'streaming', fn: function (anInteger,aBlock){ var self=this; return smalltalk.withContext(function($ctx1) { var $1,$2,$3,$4; $1=self["@stream"]; _st($1)._nextPutAll_(_st(_st("case ").__comma(_st(anInteger)._asString())).__comma(":")); $2=_st($1)._lf(); _st(self)._nextPutStatementWith_(aBlock); $3=self["@stream"]; _st($3)._nextPutAll_(_st(_st("smalltalk.thisContext.pc=").__comma(_st(_st(anInteger).__plus((1)))._asString())).__comma(";")); $4=_st($3)._lf(); return self}, function($ctx1) {$ctx1.fill(self,"nextPutStatement:with:",{anInteger:anInteger,aBlock:aBlock}, smalltalk.JSStream)})}, args: ["anInteger", "aBlock"], source: "nextPutStatement: anInteger with: aBlock\x0a\x09stream nextPutAll: 'case ', anInteger asString, ':'; lf.\x0a\x09self nextPutStatementWith: aBlock.\x0a\x09stream nextPutAll: 'smalltalk.thisContext.pc=', (anInteger + 1) asString, ';'; lf", messageSends: ["nextPutAll:", ",", "asString", "lf", "nextPutStatementWith:", "+"], referencedClasses: [] }), smalltalk.JSStream); smalltalk.addMethod( "_nextPutStatementWith_", smalltalk.method({ selector: "nextPutStatementWith:", category: 'streaming', fn: function (aBlock){ var self=this; return smalltalk.withContext(function($ctx1) { var $1,$2; _st(aBlock)._value(); $1=self["@stream"]; _st($1)._nextPutAll_(";"); $2=_st($1)._lf(); return self}, function($ctx1) {$ctx1.fill(self,"nextPutStatementWith:",{aBlock:aBlock}, smalltalk.JSStream)})}, args: ["aBlock"], source: "nextPutStatementWith: aBlock\x0a\x09aBlock value.\x0a\x09stream nextPutAll: ';'; lf", messageSends: ["value", "nextPutAll:", "lf"], referencedClasses: [] }), smalltalk.JSStream); smalltalk.addMethod( "_nextPutVar_", smalltalk.method({ selector: "nextPutVar:", category: 'streaming', fn: function (aString){ var self=this; return smalltalk.withContext(function($ctx1) { var $1,$2; $1=self["@stream"]; _st($1)._nextPutAll_(_st(_st("var ").__comma(aString)).__comma(";")); $2=_st($1)._lf(); return self}, function($ctx1) {$ctx1.fill(self,"nextPutVar:",{aString:aString}, smalltalk.JSStream)})}, args: ["aString"], source: "nextPutVar: aString\x0a\x09stream nextPutAll: 'var ', aString, ';'; lf", messageSends: ["nextPutAll:", ",", "lf"], referencedClasses: [] }), smalltalk.JSStream); smalltalk.addMethod( "_nextPutVars_", smalltalk.method({ selector: "nextPutVars:", category: 'streaming', fn: function (aCollection){ var self=this; return smalltalk.withContext(function($ctx1) { var $1,$2,$3; var $early={}; try { _st(aCollection)._ifEmpty_((function(){ return smalltalk.withContext(function($ctx2) { $1=self; throw $early=[$1]; }, function($ctx2) {$ctx2.fillBlock({},$ctx1)})})); _st(self["@stream"])._nextPutAll_("var "); _st(aCollection)._do_separatedBy_((function(each){ return smalltalk.withContext(function($ctx2) { return _st(self["@stream"])._nextPutAll_(each); }, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1)})}),(function(){ return smalltalk.withContext(function($ctx2) { return _st(self["@stream"])._nextPutAll_(","); }, function($ctx2) {$ctx2.fillBlock({},$ctx1)})})); $2=self["@stream"]; _st($2)._nextPutAll_(";"); $3=_st($2)._lf(); return self} catch(e) {if(e===$early)return e[0]; throw e} }, function($ctx1) {$ctx1.fill(self,"nextPutVars:",{aCollection:aCollection}, smalltalk.JSStream)})}, args: ["aCollection"], source: "nextPutVars: aCollection\x0a\x09aCollection ifEmpty: [ ^self ].\x0a \x0a\x09stream nextPutAll: 'var '.\x0a\x09aCollection \x0a\x09\x09do: [ :each | stream nextPutAll: each ]\x0a\x09\x09separatedBy: [ stream nextPutAll: ',' ].\x0a\x09stream nextPutAll: ';'; lf", messageSends: ["ifEmpty:", "nextPutAll:", "do:separatedBy:", "lf"], referencedClasses: [] }), smalltalk.JSStream); smalltalk.addMethod( "_appendToInstruction_", smalltalk.method({ selector: "appendToInstruction:", category: '*Compiler-IR', fn: function (anIRInstruction){ var self=this; return smalltalk.withContext(function($ctx1) { _st(anIRInstruction)._appendBlock_(self); return self}, function($ctx1) {$ctx1.fill(self,"appendToInstruction:",{anIRInstruction:anIRInstruction}, smalltalk.BlockClosure)})}, args: ["anIRInstruction"], source: "appendToInstruction: anIRInstruction\x0a anIRInstruction appendBlock: self", messageSends: ["appendBlock:"], referencedClasses: [] }), smalltalk.BlockClosure); smalltalk.addMethod( "_asVariableName", smalltalk.method({ selector: "asVariableName", category: '*Compiler-IR', fn: function (){ var self=this; return smalltalk.withContext(function($ctx1) { var $2,$1; $2=_st(_st(_st((smalltalk.Smalltalk || Smalltalk))._current())._reservedWords())._includes_(self); if(smalltalk.assert($2)){ $1=_st(self).__comma("_"); } else { $1=self; }; return $1; }, function($ctx1) {$ctx1.fill(self,"asVariableName",{}, smalltalk.String)})}, args: [], source: "asVariableName\x0a\x09^ (Smalltalk current reservedWords includes: self)\x0a\x09\x09ifTrue: [ self, '_' ]\x0a\x09\x09ifFalse: [ self ]", messageSends: ["ifTrue:ifFalse:", ",", "includes:", "reservedWords", "current"], referencedClasses: ["Smalltalk"] }), smalltalk.String);