Compiler-Core.js 33 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023
  1. define("amber_core/Compiler-Core", ["amber_vm/smalltalk", "amber_vm/nil", "amber_vm/_st", "amber_core/Kernel-Objects"], function(smalltalk,nil,_st){
  2. smalltalk.addPackage('Compiler-Core');
  3. smalltalk.packages["Compiler-Core"].transport = {"type":"amd","amdNamespace":"amber_core"};
  4. smalltalk.addClass('AbstractCodeGenerator', smalltalk.Object, ['currentClass', 'source'], 'Compiler-Core');
  5. smalltalk.AbstractCodeGenerator.comment="I am the abstract super class of all code generators and provide their common API.";
  6. smalltalk.addMethod(
  7. smalltalk.method({
  8. selector: "classNameFor:",
  9. category: 'accessing',
  10. fn: function (aClass){
  11. var self=this;
  12. return smalltalk.withContext(function($ctx1) {
  13. var $2,$3,$4,$1;
  14. $2=_st(aClass)._isMetaclass();
  15. if(smalltalk.assert($2)){
  16. $3=_st(_st(aClass)._instanceClass())._name();
  17. $ctx1.sendIdx["name"]=1;
  18. $1=_st($3).__comma(".klass");
  19. } else {
  20. $4=_st(aClass)._isNil();
  21. if(smalltalk.assert($4)){
  22. $1="nil";
  23. } else {
  24. $1=_st(aClass)._name();
  25. };
  26. };
  27. return $1;
  28. }, function($ctx1) {$ctx1.fill(self,"classNameFor:",{aClass:aClass},smalltalk.AbstractCodeGenerator)})},
  29. args: ["aClass"],
  30. source: "classNameFor: aClass\x0a\x09^aClass isMetaclass\x0a\x09\x09ifTrue: [aClass instanceClass name, '.klass']\x0a\x09\x09ifFalse: [\x0a\x09\x09aClass isNil\x0a\x09\x09\x09ifTrue: ['nil']\x0a\x09\x09\x09ifFalse: [aClass name]]",
  31. messageSends: ["ifTrue:ifFalse:", "isMetaclass", ",", "name", "instanceClass", "isNil"],
  32. referencedClasses: []
  33. }),
  34. smalltalk.AbstractCodeGenerator);
  35. smalltalk.addMethod(
  36. smalltalk.method({
  37. selector: "compileNode:",
  38. category: 'compiling',
  39. fn: function (aNode){
  40. var self=this;
  41. return smalltalk.withContext(function($ctx1) {
  42. self._subclassResponsibility();
  43. return self}, function($ctx1) {$ctx1.fill(self,"compileNode:",{aNode:aNode},smalltalk.AbstractCodeGenerator)})},
  44. args: ["aNode"],
  45. source: "compileNode: aNode\x0a\x09self subclassResponsibility",
  46. messageSends: ["subclassResponsibility"],
  47. referencedClasses: []
  48. }),
  49. smalltalk.AbstractCodeGenerator);
  50. smalltalk.addMethod(
  51. smalltalk.method({
  52. selector: "currentClass",
  53. category: 'accessing',
  54. fn: function (){
  55. var self=this;
  56. return smalltalk.withContext(function($ctx1) {
  57. var $1;
  58. $1=self["@currentClass"];
  59. return $1;
  60. }, function($ctx1) {$ctx1.fill(self,"currentClass",{},smalltalk.AbstractCodeGenerator)})},
  61. args: [],
  62. source: "currentClass\x0a\x09^currentClass",
  63. messageSends: [],
  64. referencedClasses: []
  65. }),
  66. smalltalk.AbstractCodeGenerator);
  67. smalltalk.addMethod(
  68. smalltalk.method({
  69. selector: "currentClass:",
  70. category: 'accessing',
  71. fn: function (aClass){
  72. var self=this;
  73. return smalltalk.withContext(function($ctx1) {
  74. self["@currentClass"]=aClass;
  75. return self}, function($ctx1) {$ctx1.fill(self,"currentClass:",{aClass:aClass},smalltalk.AbstractCodeGenerator)})},
  76. args: ["aClass"],
  77. source: "currentClass: aClass\x0a\x09currentClass := aClass",
  78. messageSends: [],
  79. referencedClasses: []
  80. }),
  81. smalltalk.AbstractCodeGenerator);
  82. smalltalk.addMethod(
  83. smalltalk.method({
  84. selector: "pseudoVariables",
  85. category: 'accessing',
  86. fn: function (){
  87. var self=this;
  88. function $Smalltalk(){return smalltalk.Smalltalk||(typeof Smalltalk=="undefined"?nil:Smalltalk)}
  89. return smalltalk.withContext(function($ctx1) {
  90. var $1;
  91. $1=_st(_st($Smalltalk())._current())._pseudoVariableNames();
  92. return $1;
  93. }, function($ctx1) {$ctx1.fill(self,"pseudoVariables",{},smalltalk.AbstractCodeGenerator)})},
  94. args: [],
  95. source: "pseudoVariables\x0a\x09^ Smalltalk current pseudoVariableNames",
  96. messageSends: ["pseudoVariableNames", "current"],
  97. referencedClasses: ["Smalltalk"]
  98. }),
  99. smalltalk.AbstractCodeGenerator);
  100. smalltalk.addMethod(
  101. smalltalk.method({
  102. selector: "safeVariableNameFor:",
  103. category: 'accessing',
  104. fn: function (aString){
  105. var self=this;
  106. function $Smalltalk(){return smalltalk.Smalltalk||(typeof Smalltalk=="undefined"?nil:Smalltalk)}
  107. return smalltalk.withContext(function($ctx1) {
  108. var $2,$1;
  109. $2=_st(_st(_st($Smalltalk())._current())._reservedWords())._includes_(aString);
  110. if(smalltalk.assert($2)){
  111. $1=_st(aString).__comma("_");
  112. } else {
  113. $1=aString;
  114. };
  115. return $1;
  116. }, function($ctx1) {$ctx1.fill(self,"safeVariableNameFor:",{aString:aString},smalltalk.AbstractCodeGenerator)})},
  117. args: ["aString"],
  118. source: "safeVariableNameFor: aString\x0a\x09^(Smalltalk current reservedWords includes: aString)\x0a\x09\x09ifTrue: [aString, '_']\x0a\x09\x09ifFalse: [aString]",
  119. messageSends: ["ifTrue:ifFalse:", "includes:", "reservedWords", "current", ","],
  120. referencedClasses: ["Smalltalk"]
  121. }),
  122. smalltalk.AbstractCodeGenerator);
  123. smalltalk.addMethod(
  124. smalltalk.method({
  125. selector: "source",
  126. category: 'accessing',
  127. fn: function (){
  128. var self=this;
  129. return smalltalk.withContext(function($ctx1) {
  130. var $2,$1;
  131. $2=self["@source"];
  132. if(($receiver = $2) == nil || $receiver == null){
  133. $1="";
  134. } else {
  135. $1=$2;
  136. };
  137. return $1;
  138. }, function($ctx1) {$ctx1.fill(self,"source",{},smalltalk.AbstractCodeGenerator)})},
  139. args: [],
  140. source: "source\x0a\x09^source ifNil: ['']",
  141. messageSends: ["ifNil:"],
  142. referencedClasses: []
  143. }),
  144. smalltalk.AbstractCodeGenerator);
  145. smalltalk.addMethod(
  146. smalltalk.method({
  147. selector: "source:",
  148. category: 'accessing',
  149. fn: function (aString){
  150. var self=this;
  151. return smalltalk.withContext(function($ctx1) {
  152. self["@source"]=aString;
  153. return self}, function($ctx1) {$ctx1.fill(self,"source:",{aString:aString},smalltalk.AbstractCodeGenerator)})},
  154. args: ["aString"],
  155. source: "source: aString\x0a\x09source := aString",
  156. messageSends: [],
  157. referencedClasses: []
  158. }),
  159. smalltalk.AbstractCodeGenerator);
  160. smalltalk.addClass('CodeGenerator', smalltalk.AbstractCodeGenerator, [], 'Compiler-Core');
  161. smalltalk.CodeGenerator.comment="I am a basic code generator. I generate a valid JavaScript output, but no not perform any inlining.\x0aSee `InliningCodeGenerator` for an optimized JavaScript code generation.";
  162. smalltalk.addMethod(
  163. smalltalk.method({
  164. selector: "compileNode:",
  165. category: 'compiling',
  166. fn: function (aNode){
  167. var self=this;
  168. var ir,stream;
  169. return smalltalk.withContext(function($ctx1) {
  170. var $2,$3,$1;
  171. _st(self._semanticAnalyzer())._visit_(aNode);
  172. $ctx1.sendIdx["visit:"]=1;
  173. ir=_st(self._translator())._visit_(aNode);
  174. $ctx1.sendIdx["visit:"]=2;
  175. $2=self._irTranslator();
  176. _st($2)._currentClass_(self._currentClass());
  177. _st($2)._visit_(ir);
  178. $3=_st($2)._contents();
  179. $1=$3;
  180. return $1;
  181. }, function($ctx1) {$ctx1.fill(self,"compileNode:",{aNode:aNode,ir:ir,stream:stream},smalltalk.CodeGenerator)})},
  182. args: ["aNode"],
  183. source: "compileNode: aNode\x0a\x09| ir stream |\x0a\x09self semanticAnalyzer visit: aNode.\x0a\x09ir := self translator visit: aNode.\x0a\x09^ self irTranslator\x0a\x09\x09currentClass: self currentClass;\x0a\x09\x09visit: ir;\x0a\x09\x09contents",
  184. messageSends: ["visit:", "semanticAnalyzer", "translator", "currentClass:", "irTranslator", "currentClass", "contents"],
  185. referencedClasses: []
  186. }),
  187. smalltalk.CodeGenerator);
  188. smalltalk.addMethod(
  189. smalltalk.method({
  190. selector: "irTranslator",
  191. category: 'compiling',
  192. fn: function (){
  193. var self=this;
  194. function $IRJSTranslator(){return smalltalk.IRJSTranslator||(typeof IRJSTranslator=="undefined"?nil:IRJSTranslator)}
  195. return smalltalk.withContext(function($ctx1) {
  196. var $1;
  197. $1=_st($IRJSTranslator())._new();
  198. return $1;
  199. }, function($ctx1) {$ctx1.fill(self,"irTranslator",{},smalltalk.CodeGenerator)})},
  200. args: [],
  201. source: "irTranslator\x0a\x09^ IRJSTranslator new",
  202. messageSends: ["new"],
  203. referencedClasses: ["IRJSTranslator"]
  204. }),
  205. smalltalk.CodeGenerator);
  206. smalltalk.addMethod(
  207. smalltalk.method({
  208. selector: "semanticAnalyzer",
  209. category: 'compiling',
  210. fn: function (){
  211. var self=this;
  212. function $SemanticAnalyzer(){return smalltalk.SemanticAnalyzer||(typeof SemanticAnalyzer=="undefined"?nil:SemanticAnalyzer)}
  213. return smalltalk.withContext(function($ctx1) {
  214. var $1;
  215. $1=_st($SemanticAnalyzer())._on_(self._currentClass());
  216. return $1;
  217. }, function($ctx1) {$ctx1.fill(self,"semanticAnalyzer",{},smalltalk.CodeGenerator)})},
  218. args: [],
  219. source: "semanticAnalyzer\x0a\x09^ SemanticAnalyzer on: self currentClass",
  220. messageSends: ["on:", "currentClass"],
  221. referencedClasses: ["SemanticAnalyzer"]
  222. }),
  223. smalltalk.CodeGenerator);
  224. smalltalk.addMethod(
  225. smalltalk.method({
  226. selector: "translator",
  227. category: 'compiling',
  228. fn: function (){
  229. var self=this;
  230. function $IRASTTranslator(){return smalltalk.IRASTTranslator||(typeof IRASTTranslator=="undefined"?nil:IRASTTranslator)}
  231. return smalltalk.withContext(function($ctx1) {
  232. var $2,$3,$1;
  233. $2=_st($IRASTTranslator())._new();
  234. _st($2)._source_(self._source());
  235. _st($2)._theClass_(self._currentClass());
  236. $3=_st($2)._yourself();
  237. $1=$3;
  238. return $1;
  239. }, function($ctx1) {$ctx1.fill(self,"translator",{},smalltalk.CodeGenerator)})},
  240. args: [],
  241. source: "translator\x0a\x09^ IRASTTranslator new\x0a\x09\x09source: self source;\x0a\x09\x09theClass: self currentClass;\x0a\x09\x09yourself",
  242. messageSends: ["source:", "new", "source", "theClass:", "currentClass", "yourself"],
  243. referencedClasses: ["IRASTTranslator"]
  244. }),
  245. smalltalk.CodeGenerator);
  246. smalltalk.addClass('Compiler', smalltalk.Object, ['currentClass', 'source', 'unknownVariables', 'codeGeneratorClass'], 'Compiler-Core');
  247. smalltalk.Compiler.comment="I provide the public interface for compiling Amber source code into JavaScript.\x0a\x0aThe code generator used to produce JavaScript can be plugged with `#codeGeneratorClass`.\x0aThe default code generator is an instance of `InlinedCodeGenerator`";
  248. smalltalk.addMethod(
  249. smalltalk.method({
  250. selector: "codeGeneratorClass",
  251. category: 'accessing',
  252. fn: function (){
  253. var self=this;
  254. function $InliningCodeGenerator(){return smalltalk.InliningCodeGenerator||(typeof InliningCodeGenerator=="undefined"?nil:InliningCodeGenerator)}
  255. return smalltalk.withContext(function($ctx1) {
  256. var $2,$1;
  257. $2=self["@codeGeneratorClass"];
  258. if(($receiver = $2) == nil || $receiver == null){
  259. $1=$InliningCodeGenerator();
  260. } else {
  261. $1=$2;
  262. };
  263. return $1;
  264. }, function($ctx1) {$ctx1.fill(self,"codeGeneratorClass",{},smalltalk.Compiler)})},
  265. args: [],
  266. source: "codeGeneratorClass\x0a\x09^codeGeneratorClass ifNil: [InliningCodeGenerator]",
  267. messageSends: ["ifNil:"],
  268. referencedClasses: ["InliningCodeGenerator"]
  269. }),
  270. smalltalk.Compiler);
  271. smalltalk.addMethod(
  272. smalltalk.method({
  273. selector: "codeGeneratorClass:",
  274. category: 'accessing',
  275. fn: function (aClass){
  276. var self=this;
  277. return smalltalk.withContext(function($ctx1) {
  278. self["@codeGeneratorClass"]=aClass;
  279. return self}, function($ctx1) {$ctx1.fill(self,"codeGeneratorClass:",{aClass:aClass},smalltalk.Compiler)})},
  280. args: ["aClass"],
  281. source: "codeGeneratorClass: aClass\x0a\x09codeGeneratorClass := aClass",
  282. messageSends: [],
  283. referencedClasses: []
  284. }),
  285. smalltalk.Compiler);
  286. smalltalk.addMethod(
  287. smalltalk.method({
  288. selector: "compile:",
  289. category: 'compiling',
  290. fn: function (aString){
  291. var self=this;
  292. return smalltalk.withContext(function($ctx1) {
  293. var $1;
  294. $1=self._compileNode_(self._parse_(aString));
  295. return $1;
  296. }, function($ctx1) {$ctx1.fill(self,"compile:",{aString:aString},smalltalk.Compiler)})},
  297. args: ["aString"],
  298. source: "compile: aString\x0a\x09^self compileNode: (self parse: aString)",
  299. messageSends: ["compileNode:", "parse:"],
  300. referencedClasses: []
  301. }),
  302. smalltalk.Compiler);
  303. smalltalk.addMethod(
  304. smalltalk.method({
  305. selector: "compile:forClass:",
  306. category: 'compiling',
  307. fn: function (aString,aClass){
  308. var self=this;
  309. return smalltalk.withContext(function($ctx1) {
  310. var $1;
  311. self._currentClass_(aClass);
  312. self._source_(aString);
  313. $1=self._compile_(aString);
  314. return $1;
  315. }, function($ctx1) {$ctx1.fill(self,"compile:forClass:",{aString:aString,aClass:aClass},smalltalk.Compiler)})},
  316. args: ["aString", "aClass"],
  317. source: "compile: aString forClass: aClass\x0a\x09self currentClass: aClass.\x0a\x09self source: aString.\x0a\x09^self compile: aString",
  318. messageSends: ["currentClass:", "source:", "compile:"],
  319. referencedClasses: []
  320. }),
  321. smalltalk.Compiler);
  322. smalltalk.addMethod(
  323. smalltalk.method({
  324. selector: "compileExpression:",
  325. category: 'compiling',
  326. fn: function (aString){
  327. var self=this;
  328. function $DoIt(){return smalltalk.DoIt||(typeof DoIt=="undefined"?nil:DoIt)}
  329. return smalltalk.withContext(function($ctx1) {
  330. var $2,$1,$3;
  331. self._currentClass_($DoIt());
  332. $2="doIt ^[".__comma(aString);
  333. $1=_st($2).__comma("] value");
  334. $ctx1.sendIdx[","]=1;
  335. self._source_($1);
  336. $3=self._compileNode_(self._parse_(self._source()));
  337. return $3;
  338. }, function($ctx1) {$ctx1.fill(self,"compileExpression:",{aString:aString},smalltalk.Compiler)})},
  339. args: ["aString"],
  340. source: "compileExpression: aString\x0a\x09self currentClass: DoIt.\x0a\x09self source: 'doIt ^[', aString, '] value'.\x0a\x09^self compileNode: (self parse: self source)",
  341. messageSends: ["currentClass:", "source:", ",", "compileNode:", "parse:", "source"],
  342. referencedClasses: ["DoIt"]
  343. }),
  344. smalltalk.Compiler);
  345. smalltalk.addMethod(
  346. smalltalk.method({
  347. selector: "compileExpression:on:",
  348. category: 'compiling',
  349. fn: function (aString,anObject){
  350. var self=this;
  351. return smalltalk.withContext(function($ctx1) {
  352. var $2,$1,$3;
  353. self._currentClass_(_st(anObject)._class());
  354. $2="xxxDoIt ^[".__comma(aString);
  355. $1=_st($2).__comma("] value");
  356. $ctx1.sendIdx[","]=1;
  357. self._source_($1);
  358. $3=self._compileNode_(self._parse_(self._source()));
  359. return $3;
  360. }, function($ctx1) {$ctx1.fill(self,"compileExpression:on:",{aString:aString,anObject:anObject},smalltalk.Compiler)})},
  361. args: ["aString", "anObject"],
  362. source: "compileExpression: aString on: anObject\x0a\x09self currentClass: anObject class.\x0a\x09self source: 'xxxDoIt ^[', aString, '] value'.\x0a\x09^self compileNode: (self parse: self source)",
  363. messageSends: ["currentClass:", "class", "source:", ",", "compileNode:", "parse:", "source"],
  364. referencedClasses: []
  365. }),
  366. smalltalk.Compiler);
  367. smalltalk.addMethod(
  368. smalltalk.method({
  369. selector: "compileNode:",
  370. category: 'compiling',
  371. fn: function (aNode){
  372. var self=this;
  373. var generator,result;
  374. return smalltalk.withContext(function($ctx1) {
  375. var $1,$2,$3;
  376. generator=_st(self._codeGeneratorClass())._new();
  377. $1=generator;
  378. _st($1)._source_(self._source());
  379. $2=_st($1)._currentClass_(self._currentClass());
  380. result=_st(generator)._compileNode_(aNode);
  381. self._unknownVariables_([]);
  382. $3=result;
  383. return $3;
  384. }, function($ctx1) {$ctx1.fill(self,"compileNode:",{aNode:aNode,generator:generator,result:result},smalltalk.Compiler)})},
  385. args: ["aNode"],
  386. source: "compileNode: aNode\x0a\x09| generator result |\x0a\x09generator := self codeGeneratorClass new.\x0a\x09generator\x0a\x09\x09source: self source;\x0a\x09\x09currentClass: self currentClass.\x0a\x09result := generator compileNode: aNode.\x0a\x09self unknownVariables: #().\x0a\x09^result",
  387. messageSends: ["new", "codeGeneratorClass", "source:", "source", "currentClass:", "currentClass", "compileNode:", "unknownVariables:"],
  388. referencedClasses: []
  389. }),
  390. smalltalk.Compiler);
  391. smalltalk.addMethod(
  392. smalltalk.method({
  393. selector: "currentClass",
  394. category: 'accessing',
  395. fn: function (){
  396. var self=this;
  397. return smalltalk.withContext(function($ctx1) {
  398. var $1;
  399. $1=self["@currentClass"];
  400. return $1;
  401. }, function($ctx1) {$ctx1.fill(self,"currentClass",{},smalltalk.Compiler)})},
  402. args: [],
  403. source: "currentClass\x0a\x09^currentClass",
  404. messageSends: [],
  405. referencedClasses: []
  406. }),
  407. smalltalk.Compiler);
  408. smalltalk.addMethod(
  409. smalltalk.method({
  410. selector: "currentClass:",
  411. category: 'accessing',
  412. fn: function (aClass){
  413. var self=this;
  414. return smalltalk.withContext(function($ctx1) {
  415. self["@currentClass"]=aClass;
  416. return self}, function($ctx1) {$ctx1.fill(self,"currentClass:",{aClass:aClass},smalltalk.Compiler)})},
  417. args: ["aClass"],
  418. source: "currentClass: aClass\x0a\x09currentClass := aClass",
  419. messageSends: [],
  420. referencedClasses: []
  421. }),
  422. smalltalk.Compiler);
  423. smalltalk.addMethod(
  424. smalltalk.method({
  425. selector: "eval:",
  426. category: 'compiling',
  427. fn: function (aString){
  428. var self=this;
  429. return smalltalk.withContext(function($ctx1) {
  430. return eval(aString);
  431. return self}, function($ctx1) {$ctx1.fill(self,"eval:",{aString:aString},smalltalk.Compiler)})},
  432. args: ["aString"],
  433. source: "eval: aString\x0a\x09<return eval(aString)>",
  434. messageSends: [],
  435. referencedClasses: []
  436. }),
  437. smalltalk.Compiler);
  438. smalltalk.addMethod(
  439. smalltalk.method({
  440. selector: "evaluateExpression:",
  441. category: 'compiling',
  442. fn: function (aString){
  443. var self=this;
  444. function $DoIt(){return smalltalk.DoIt||(typeof DoIt=="undefined"?nil:DoIt)}
  445. return smalltalk.withContext(function($ctx1) {
  446. var $1;
  447. $1=self._evaluateExpression_on_(aString,_st($DoIt())._new());
  448. return $1;
  449. }, function($ctx1) {$ctx1.fill(self,"evaluateExpression:",{aString:aString},smalltalk.Compiler)})},
  450. args: ["aString"],
  451. source: "evaluateExpression: aString\x0a\x09\x22Unlike #eval: evaluate a Smalltalk expression and answer the returned object\x22\x0a\x09^ self evaluateExpression: aString on: DoIt new",
  452. messageSends: ["evaluateExpression:on:", "new"],
  453. referencedClasses: ["DoIt"]
  454. }),
  455. smalltalk.Compiler);
  456. smalltalk.addMethod(
  457. smalltalk.method({
  458. selector: "evaluateExpression:on:",
  459. category: 'compiling',
  460. fn: function (aString,anObject){
  461. var self=this;
  462. var result,method;
  463. return smalltalk.withContext(function($ctx1) {
  464. var $1,$2,$3;
  465. method=self._eval_(self._compileExpression_on_(aString,anObject));
  466. _st(method)._category_("xxxDoIt");
  467. $1=_st(anObject)._class();
  468. $ctx1.sendIdx["class"]=1;
  469. _st($1)._addCompiledMethod_(method);
  470. result=_st(anObject)._xxxDoIt();
  471. $2=_st(anObject)._class();
  472. _st($2)._removeCompiledMethod_(method);
  473. $3=result;
  474. return $3;
  475. }, function($ctx1) {$ctx1.fill(self,"evaluateExpression:on:",{aString:aString,anObject:anObject,result:result,method:method},smalltalk.Compiler)})},
  476. args: ["aString", "anObject"],
  477. source: "evaluateExpression: aString on: anObject\x0a\x09\x22Unlike #eval: evaluate a Smalltalk expression with anObject as the receiver and answer the returned object\x22\x0a\x09| result method |\x0a\x09method := self eval: (self compileExpression: aString on: anObject).\x0a\x09method category: 'xxxDoIt'.\x0a\x09anObject class addCompiledMethod: method.\x0a\x09result := anObject xxxDoIt.\x0a\x09anObject class removeCompiledMethod: method.\x0a\x09^result",
  478. messageSends: ["eval:", "compileExpression:on:", "category:", "addCompiledMethod:", "class", "xxxDoIt", "removeCompiledMethod:"],
  479. referencedClasses: []
  480. }),
  481. smalltalk.Compiler);
  482. smalltalk.addMethod(
  483. smalltalk.method({
  484. selector: "install:forClass:category:",
  485. category: 'compiling',
  486. fn: function (aString,aBehavior,anotherString){
  487. var self=this;
  488. function $ClassBuilder(){return smalltalk.ClassBuilder||(typeof ClassBuilder=="undefined"?nil:ClassBuilder)}
  489. return smalltalk.withContext(function($ctx1) {
  490. var $1;
  491. $1=_st(_st($ClassBuilder())._new())._installMethod_forClass_category_(self._eval_(self._compile_forClass_(aString,aBehavior)),aBehavior,anotherString);
  492. return $1;
  493. }, function($ctx1) {$ctx1.fill(self,"install:forClass:category:",{aString:aString,aBehavior:aBehavior,anotherString:anotherString},smalltalk.Compiler)})},
  494. args: ["aString", "aBehavior", "anotherString"],
  495. source: "install: aString forClass: aBehavior category: anotherString\x0a\x09^ ClassBuilder new\x0a\x09\x09installMethod: (self eval: (self compile: aString forClass: aBehavior))\x0a\x09\x09forClass: aBehavior\x0a\x09\x09category: anotherString",
  496. messageSends: ["installMethod:forClass:category:", "new", "eval:", "compile:forClass:"],
  497. referencedClasses: ["ClassBuilder"]
  498. }),
  499. smalltalk.Compiler);
  500. smalltalk.addMethod(
  501. smalltalk.method({
  502. selector: "parse:",
  503. category: 'compiling',
  504. fn: function (aString){
  505. var self=this;
  506. function $Smalltalk(){return smalltalk.Smalltalk||(typeof Smalltalk=="undefined"?nil:Smalltalk)}
  507. return smalltalk.withContext(function($ctx1) {
  508. var $1;
  509. $1=_st(_st($Smalltalk())._current())._parse_(aString);
  510. return $1;
  511. }, function($ctx1) {$ctx1.fill(self,"parse:",{aString:aString},smalltalk.Compiler)})},
  512. args: ["aString"],
  513. source: "parse: aString\x0a\x09^Smalltalk current parse: aString",
  514. messageSends: ["parse:", "current"],
  515. referencedClasses: ["Smalltalk"]
  516. }),
  517. smalltalk.Compiler);
  518. smalltalk.addMethod(
  519. smalltalk.method({
  520. selector: "parseExpression:",
  521. category: 'compiling',
  522. fn: function (aString){
  523. var self=this;
  524. return smalltalk.withContext(function($ctx1) {
  525. var $3,$2,$1;
  526. $3="doIt ^[".__comma(aString);
  527. $2=_st($3).__comma("] value");
  528. $ctx1.sendIdx[","]=1;
  529. $1=self._parse_($2);
  530. return $1;
  531. }, function($ctx1) {$ctx1.fill(self,"parseExpression:",{aString:aString},smalltalk.Compiler)})},
  532. args: ["aString"],
  533. source: "parseExpression: aString\x0a\x09^self parse: 'doIt ^[', aString, '] value'",
  534. messageSends: ["parse:", ","],
  535. referencedClasses: []
  536. }),
  537. smalltalk.Compiler);
  538. smalltalk.addMethod(
  539. smalltalk.method({
  540. selector: "recompile:",
  541. category: 'compiling',
  542. fn: function (aClass){
  543. var self=this;
  544. return smalltalk.withContext(function($ctx1) {
  545. var $1;
  546. _st(_st(_st(aClass)._methodDictionary())._values())._do_displayingProgress_((function(each){
  547. return smalltalk.withContext(function($ctx2) {
  548. return self._install_forClass_category_(_st(each)._source(),aClass,_st(each)._category());
  549. }, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1,1)})}),"Recompiling ".__comma(_st(aClass)._name()));
  550. $1=_st(aClass)._isMetaclass();
  551. if(! smalltalk.assert($1)){
  552. self._recompile_(_st(aClass)._class());
  553. };
  554. return self}, function($ctx1) {$ctx1.fill(self,"recompile:",{aClass:aClass},smalltalk.Compiler)})},
  555. args: ["aClass"],
  556. source: "recompile: aClass\x0a\x09aClass methodDictionary values\x0a\x09\x09do: [ :each | self install: each source forClass: aClass category: each category ]\x0a\x09\x09displayingProgress: 'Recompiling ', aClass name.\x0a\x09\x22self setupClass: aClass.\x22\x0a\x09aClass isMetaclass ifFalse: [ self recompile: aClass class ]",
  557. messageSends: ["do:displayingProgress:", "values", "methodDictionary", "install:forClass:category:", "source", "category", ",", "name", "ifFalse:", "isMetaclass", "recompile:", "class"],
  558. referencedClasses: []
  559. }),
  560. smalltalk.Compiler);
  561. smalltalk.addMethod(
  562. smalltalk.method({
  563. selector: "recompileAll",
  564. category: 'compiling',
  565. fn: function (){
  566. var self=this;
  567. function $Smalltalk(){return smalltalk.Smalltalk||(typeof Smalltalk=="undefined"?nil:Smalltalk)}
  568. return smalltalk.withContext(function($ctx1) {
  569. _st(_st(_st($Smalltalk())._current())._classes())._do_displayingProgress_((function(each){
  570. return smalltalk.withContext(function($ctx2) {
  571. return self._recompile_(each);
  572. }, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1,1)})}),"Compiling all classes...");
  573. return self}, function($ctx1) {$ctx1.fill(self,"recompileAll",{},smalltalk.Compiler)})},
  574. args: [],
  575. source: "recompileAll\x0a\x09Smalltalk current classes \x0a\x09\x09do: [:each | self recompile: each ]\x0a\x09\x09displayingProgress: 'Compiling all classes...'",
  576. messageSends: ["do:displayingProgress:", "classes", "current", "recompile:"],
  577. referencedClasses: ["Smalltalk"]
  578. }),
  579. smalltalk.Compiler);
  580. smalltalk.addMethod(
  581. smalltalk.method({
  582. selector: "source",
  583. category: 'accessing',
  584. fn: function (){
  585. var self=this;
  586. return smalltalk.withContext(function($ctx1) {
  587. var $2,$1;
  588. $2=self["@source"];
  589. if(($receiver = $2) == nil || $receiver == null){
  590. $1="";
  591. } else {
  592. $1=$2;
  593. };
  594. return $1;
  595. }, function($ctx1) {$ctx1.fill(self,"source",{},smalltalk.Compiler)})},
  596. args: [],
  597. source: "source\x0a\x09^source ifNil: ['']",
  598. messageSends: ["ifNil:"],
  599. referencedClasses: []
  600. }),
  601. smalltalk.Compiler);
  602. smalltalk.addMethod(
  603. smalltalk.method({
  604. selector: "source:",
  605. category: 'accessing',
  606. fn: function (aString){
  607. var self=this;
  608. return smalltalk.withContext(function($ctx1) {
  609. self["@source"]=aString;
  610. return self}, function($ctx1) {$ctx1.fill(self,"source:",{aString:aString},smalltalk.Compiler)})},
  611. args: ["aString"],
  612. source: "source: aString\x0a\x09source := aString",
  613. messageSends: [],
  614. referencedClasses: []
  615. }),
  616. smalltalk.Compiler);
  617. smalltalk.addMethod(
  618. smalltalk.method({
  619. selector: "unknownVariables",
  620. category: 'accessing',
  621. fn: function (){
  622. var self=this;
  623. return smalltalk.withContext(function($ctx1) {
  624. var $1;
  625. $1=self["@unknownVariables"];
  626. return $1;
  627. }, function($ctx1) {$ctx1.fill(self,"unknownVariables",{},smalltalk.Compiler)})},
  628. args: [],
  629. source: "unknownVariables\x0a\x09^unknownVariables",
  630. messageSends: [],
  631. referencedClasses: []
  632. }),
  633. smalltalk.Compiler);
  634. smalltalk.addMethod(
  635. smalltalk.method({
  636. selector: "unknownVariables:",
  637. category: 'accessing',
  638. fn: function (aCollection){
  639. var self=this;
  640. return smalltalk.withContext(function($ctx1) {
  641. self["@unknownVariables"]=aCollection;
  642. return self}, function($ctx1) {$ctx1.fill(self,"unknownVariables:",{aCollection:aCollection},smalltalk.Compiler)})},
  643. args: ["aCollection"],
  644. source: "unknownVariables: aCollection\x0a\x09unknownVariables := aCollection",
  645. messageSends: [],
  646. referencedClasses: []
  647. }),
  648. smalltalk.Compiler);
  649. smalltalk.addMethod(
  650. smalltalk.method({
  651. selector: "recompile:",
  652. category: 'compiling',
  653. fn: function (aClass){
  654. var self=this;
  655. return smalltalk.withContext(function($ctx1) {
  656. _st(self._new())._recompile_(aClass);
  657. return self}, function($ctx1) {$ctx1.fill(self,"recompile:",{aClass:aClass},smalltalk.Compiler.klass)})},
  658. args: ["aClass"],
  659. source: "recompile: aClass\x0a\x09self new recompile: aClass",
  660. messageSends: ["recompile:", "new"],
  661. referencedClasses: []
  662. }),
  663. smalltalk.Compiler.klass);
  664. smalltalk.addMethod(
  665. smalltalk.method({
  666. selector: "recompileAll",
  667. category: 'compiling',
  668. fn: function (){
  669. var self=this;
  670. function $Smalltalk(){return smalltalk.Smalltalk||(typeof Smalltalk=="undefined"?nil:Smalltalk)}
  671. return smalltalk.withContext(function($ctx1) {
  672. _st(_st(_st($Smalltalk())._current())._classes())._do_((function(each){
  673. return smalltalk.withContext(function($ctx2) {
  674. return self._recompile_(each);
  675. }, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1,1)})}));
  676. return self}, function($ctx1) {$ctx1.fill(self,"recompileAll",{},smalltalk.Compiler.klass)})},
  677. args: [],
  678. source: "recompileAll\x0a\x09Smalltalk current classes do: [:each |\x0a\x09\x09self recompile: each]",
  679. messageSends: ["do:", "classes", "current", "recompile:"],
  680. referencedClasses: ["Smalltalk"]
  681. }),
  682. smalltalk.Compiler.klass);
  683. smalltalk.addClass('DoIt', smalltalk.Object, [], 'Compiler-Core');
  684. smalltalk.DoIt.comment="`DoIt` is the class used to compile and evaluate expressions. See `Compiler >> evaluateExpression:`.";
  685. smalltalk.addClass('NodeVisitor', smalltalk.Object, [], 'Compiler-Core');
  686. smalltalk.NodeVisitor.comment="I am the abstract super class of all AST node visitors.";
  687. smalltalk.addMethod(
  688. smalltalk.method({
  689. selector: "visit:",
  690. category: 'visiting',
  691. fn: function (aNode){
  692. var self=this;
  693. return smalltalk.withContext(function($ctx1) {
  694. var $1;
  695. $1=_st(aNode)._accept_(self);
  696. return $1;
  697. }, function($ctx1) {$ctx1.fill(self,"visit:",{aNode:aNode},smalltalk.NodeVisitor)})},
  698. args: ["aNode"],
  699. source: "visit: aNode\x0a\x09^ aNode accept: self",
  700. messageSends: ["accept:"],
  701. referencedClasses: []
  702. }),
  703. smalltalk.NodeVisitor);
  704. smalltalk.addMethod(
  705. smalltalk.method({
  706. selector: "visitAll:",
  707. category: 'visiting',
  708. fn: function (aCollection){
  709. var self=this;
  710. return smalltalk.withContext(function($ctx1) {
  711. var $1;
  712. $1=_st(aCollection)._collect_((function(each){
  713. return smalltalk.withContext(function($ctx2) {
  714. return self._visit_(each);
  715. }, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1,1)})}));
  716. return $1;
  717. }, function($ctx1) {$ctx1.fill(self,"visitAll:",{aCollection:aCollection},smalltalk.NodeVisitor)})},
  718. args: ["aCollection"],
  719. source: "visitAll: aCollection\x0a\x09^ aCollection collect: [ :each | self visit: each ]",
  720. messageSends: ["collect:", "visit:"],
  721. referencedClasses: []
  722. }),
  723. smalltalk.NodeVisitor);
  724. smalltalk.addMethod(
  725. smalltalk.method({
  726. selector: "visitAssignmentNode:",
  727. category: 'visiting',
  728. fn: function (aNode){
  729. var self=this;
  730. return smalltalk.withContext(function($ctx1) {
  731. var $1;
  732. $1=self._visitNode_(aNode);
  733. return $1;
  734. }, function($ctx1) {$ctx1.fill(self,"visitAssignmentNode:",{aNode:aNode},smalltalk.NodeVisitor)})},
  735. args: ["aNode"],
  736. source: "visitAssignmentNode: aNode\x0a\x09^ self visitNode: aNode",
  737. messageSends: ["visitNode:"],
  738. referencedClasses: []
  739. }),
  740. smalltalk.NodeVisitor);
  741. smalltalk.addMethod(
  742. smalltalk.method({
  743. selector: "visitBlockNode:",
  744. category: 'visiting',
  745. fn: function (aNode){
  746. var self=this;
  747. return smalltalk.withContext(function($ctx1) {
  748. var $1;
  749. $1=self._visitNode_(aNode);
  750. return $1;
  751. }, function($ctx1) {$ctx1.fill(self,"visitBlockNode:",{aNode:aNode},smalltalk.NodeVisitor)})},
  752. args: ["aNode"],
  753. source: "visitBlockNode: aNode\x0a\x09^ self visitNode: aNode",
  754. messageSends: ["visitNode:"],
  755. referencedClasses: []
  756. }),
  757. smalltalk.NodeVisitor);
  758. smalltalk.addMethod(
  759. smalltalk.method({
  760. selector: "visitBlockSequenceNode:",
  761. category: 'visiting',
  762. fn: function (aNode){
  763. var self=this;
  764. return smalltalk.withContext(function($ctx1) {
  765. var $1;
  766. $1=self._visitSequenceNode_(aNode);
  767. return $1;
  768. }, function($ctx1) {$ctx1.fill(self,"visitBlockSequenceNode:",{aNode:aNode},smalltalk.NodeVisitor)})},
  769. args: ["aNode"],
  770. source: "visitBlockSequenceNode: aNode\x0a\x09^ self visitSequenceNode: aNode",
  771. messageSends: ["visitSequenceNode:"],
  772. referencedClasses: []
  773. }),
  774. smalltalk.NodeVisitor);
  775. smalltalk.addMethod(
  776. smalltalk.method({
  777. selector: "visitCascadeNode:",
  778. category: 'visiting',
  779. fn: function (aNode){
  780. var self=this;
  781. return smalltalk.withContext(function($ctx1) {
  782. var $1;
  783. $1=self._visitNode_(aNode);
  784. return $1;
  785. }, function($ctx1) {$ctx1.fill(self,"visitCascadeNode:",{aNode:aNode},smalltalk.NodeVisitor)})},
  786. args: ["aNode"],
  787. source: "visitCascadeNode: aNode\x0a\x09^ self visitNode: aNode",
  788. messageSends: ["visitNode:"],
  789. referencedClasses: []
  790. }),
  791. smalltalk.NodeVisitor);
  792. smalltalk.addMethod(
  793. smalltalk.method({
  794. selector: "visitDynamicArrayNode:",
  795. category: 'visiting',
  796. fn: function (aNode){
  797. var self=this;
  798. return smalltalk.withContext(function($ctx1) {
  799. var $1;
  800. $1=self._visitNode_(aNode);
  801. return $1;
  802. }, function($ctx1) {$ctx1.fill(self,"visitDynamicArrayNode:",{aNode:aNode},smalltalk.NodeVisitor)})},
  803. args: ["aNode"],
  804. source: "visitDynamicArrayNode: aNode\x0a\x09^ self visitNode: aNode",
  805. messageSends: ["visitNode:"],
  806. referencedClasses: []
  807. }),
  808. smalltalk.NodeVisitor);
  809. smalltalk.addMethod(
  810. smalltalk.method({
  811. selector: "visitDynamicDictionaryNode:",
  812. category: 'visiting',
  813. fn: function (aNode){
  814. var self=this;
  815. return smalltalk.withContext(function($ctx1) {
  816. var $1;
  817. $1=self._visitNode_(aNode);
  818. return $1;
  819. }, function($ctx1) {$ctx1.fill(self,"visitDynamicDictionaryNode:",{aNode:aNode},smalltalk.NodeVisitor)})},
  820. args: ["aNode"],
  821. source: "visitDynamicDictionaryNode: aNode\x0a\x09^ self visitNode: aNode",
  822. messageSends: ["visitNode:"],
  823. referencedClasses: []
  824. }),
  825. smalltalk.NodeVisitor);
  826. smalltalk.addMethod(
  827. smalltalk.method({
  828. selector: "visitJSStatementNode:",
  829. category: 'visiting',
  830. fn: function (aNode){
  831. var self=this;
  832. return smalltalk.withContext(function($ctx1) {
  833. var $1;
  834. $1=self._visitNode_(aNode);
  835. return $1;
  836. }, function($ctx1) {$ctx1.fill(self,"visitJSStatementNode:",{aNode:aNode},smalltalk.NodeVisitor)})},
  837. args: ["aNode"],
  838. source: "visitJSStatementNode: aNode\x0a\x09^ self visitNode: aNode",
  839. messageSends: ["visitNode:"],
  840. referencedClasses: []
  841. }),
  842. smalltalk.NodeVisitor);
  843. smalltalk.addMethod(
  844. smalltalk.method({
  845. selector: "visitMethodNode:",
  846. category: 'visiting',
  847. fn: function (aNode){
  848. var self=this;
  849. return smalltalk.withContext(function($ctx1) {
  850. var $1;
  851. $1=self._visitNode_(aNode);
  852. return $1;
  853. }, function($ctx1) {$ctx1.fill(self,"visitMethodNode:",{aNode:aNode},smalltalk.NodeVisitor)})},
  854. args: ["aNode"],
  855. source: "visitMethodNode: aNode\x0a\x09^ self visitNode: aNode",
  856. messageSends: ["visitNode:"],
  857. referencedClasses: []
  858. }),
  859. smalltalk.NodeVisitor);
  860. smalltalk.addMethod(
  861. smalltalk.method({
  862. selector: "visitNode:",
  863. category: 'visiting',
  864. fn: function (aNode){
  865. var self=this;
  866. return smalltalk.withContext(function($ctx1) {
  867. var $1;
  868. $1=self._visitAll_(_st(aNode)._nodes());
  869. return $1;
  870. }, function($ctx1) {$ctx1.fill(self,"visitNode:",{aNode:aNode},smalltalk.NodeVisitor)})},
  871. args: ["aNode"],
  872. source: "visitNode: aNode\x0a\x09^ self visitAll: aNode nodes",
  873. messageSends: ["visitAll:", "nodes"],
  874. referencedClasses: []
  875. }),
  876. smalltalk.NodeVisitor);
  877. smalltalk.addMethod(
  878. smalltalk.method({
  879. selector: "visitReturnNode:",
  880. category: 'visiting',
  881. fn: function (aNode){
  882. var self=this;
  883. return smalltalk.withContext(function($ctx1) {
  884. var $1;
  885. $1=self._visitNode_(aNode);
  886. return $1;
  887. }, function($ctx1) {$ctx1.fill(self,"visitReturnNode:",{aNode:aNode},smalltalk.NodeVisitor)})},
  888. args: ["aNode"],
  889. source: "visitReturnNode: aNode\x0a\x09^ self visitNode: aNode",
  890. messageSends: ["visitNode:"],
  891. referencedClasses: []
  892. }),
  893. smalltalk.NodeVisitor);
  894. smalltalk.addMethod(
  895. smalltalk.method({
  896. selector: "visitSendNode:",
  897. category: 'visiting',
  898. fn: function (aNode){
  899. var self=this;
  900. return smalltalk.withContext(function($ctx1) {
  901. var $1;
  902. $1=self._visitNode_(aNode);
  903. return $1;
  904. }, function($ctx1) {$ctx1.fill(self,"visitSendNode:",{aNode:aNode},smalltalk.NodeVisitor)})},
  905. args: ["aNode"],
  906. source: "visitSendNode: aNode\x0a\x09^ self visitNode: aNode",
  907. messageSends: ["visitNode:"],
  908. referencedClasses: []
  909. }),
  910. smalltalk.NodeVisitor);
  911. smalltalk.addMethod(
  912. smalltalk.method({
  913. selector: "visitSequenceNode:",
  914. category: 'visiting',
  915. fn: function (aNode){
  916. var self=this;
  917. return smalltalk.withContext(function($ctx1) {
  918. var $1;
  919. $1=self._visitNode_(aNode);
  920. return $1;
  921. }, function($ctx1) {$ctx1.fill(self,"visitSequenceNode:",{aNode:aNode},smalltalk.NodeVisitor)})},
  922. args: ["aNode"],
  923. source: "visitSequenceNode: aNode\x0a\x09^ self visitNode: aNode",
  924. messageSends: ["visitNode:"],
  925. referencedClasses: []
  926. }),
  927. smalltalk.NodeVisitor);
  928. smalltalk.addMethod(
  929. smalltalk.method({
  930. selector: "visitValueNode:",
  931. category: 'visiting',
  932. fn: function (aNode){
  933. var self=this;
  934. return smalltalk.withContext(function($ctx1) {
  935. var $1;
  936. $1=self._visitNode_(aNode);
  937. return $1;
  938. }, function($ctx1) {$ctx1.fill(self,"visitValueNode:",{aNode:aNode},smalltalk.NodeVisitor)})},
  939. args: ["aNode"],
  940. source: "visitValueNode: aNode\x0a\x09^ self visitNode: aNode",
  941. messageSends: ["visitNode:"],
  942. referencedClasses: []
  943. }),
  944. smalltalk.NodeVisitor);
  945. smalltalk.addMethod(
  946. smalltalk.method({
  947. selector: "visitVariableNode:",
  948. category: 'visiting',
  949. fn: function (aNode){
  950. var self=this;
  951. return smalltalk.withContext(function($ctx1) {
  952. var $1;
  953. $1=self._visitNode_(aNode);
  954. return $1;
  955. }, function($ctx1) {$ctx1.fill(self,"visitVariableNode:",{aNode:aNode},smalltalk.NodeVisitor)})},
  956. args: ["aNode"],
  957. source: "visitVariableNode: aNode\x0a\x09^ self visitNode: aNode",
  958. messageSends: ["visitNode:"],
  959. referencedClasses: []
  960. }),
  961. smalltalk.NodeVisitor);
  962. });