Compiler-AST.js 62 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853185418551856185718581859186018611862186318641865186618671868186918701871187218731874187518761877187818791880188118821883188418851886188718881889189018911892189318941895189618971898189919001901190219031904190519061907190819091910191119121913191419151916191719181919192019211922192319241925192619271928192919301931193219331934193519361937193819391940194119421943194419451946194719481949195019511952195319541955195619571958195919601961196219631964196519661967196819691970197119721973197419751976197719781979198019811982198319841985198619871988198919901991199219931994199519961997199819992000200120022003200420052006200720082009201020112012201320142015201620172018201920202021202220232024202520262027202820292030203120322033203420352036203720382039204020412042204320442045204620472048204920502051205220532054205520562057205820592060206120622063206420652066206720682069207020712072207320742075207620772078207920802081208220832084208520862087208820892090209120922093209420952096209720982099210021012102210321042105210621072108210921102111211221132114211521162117211821192120212121222123212421252126212721282129213021312132213321342135213621372138213921402141214221432144214521462147214821492150215121522153215421552156215721582159216021612162216321642165216621672168216921702171217221732174217521762177217821792180218121822183218421852186218721882189219021912192219321942195219621972198219922002201220222032204220522062207220822092210221122122213221422152216221722182219222022212222222322242225222622272228222922302231223222332234223522362237223822392240224122422243224422452246224722482249225022512252225322542255
  1. smalltalk.addPackage('Compiler-AST');
  2. smalltalk.addClass('Node', smalltalk.Object, ['parent', 'position', 'nodes', 'shouldBeInlined', 'shouldBeAliased'], 'Compiler-AST');
  3. smalltalk.Node.comment="I am the abstract root class of the abstract syntax tree.\x0a\x0aConcrete classes should implement `#accept:` to allow visiting.\x0a\x0a`position` holds a point containing line and column number of the symbol location in the original source file.";
  4. smalltalk.addMethod(
  5. smalltalk.method({
  6. selector: "accept:",
  7. category: 'visiting',
  8. fn: function (aVisitor){
  9. var self=this;
  10. return smalltalk.withContext(function($ctx1) {
  11. var $1;
  12. $1=_st(aVisitor)._visitNode_(self);
  13. return $1;
  14. }, function($ctx1) {$ctx1.fill(self,"accept:",{aVisitor:aVisitor},smalltalk.Node)})},
  15. args: ["aVisitor"],
  16. source: "accept: aVisitor\x0a\x09^ aVisitor visitNode: self",
  17. messageSends: ["visitNode:"],
  18. referencedClasses: []
  19. }),
  20. smalltalk.Node);
  21. smalltalk.addMethod(
  22. smalltalk.method({
  23. selector: "addNode:",
  24. category: 'accessing',
  25. fn: function (aNode){
  26. var self=this;
  27. return smalltalk.withContext(function($ctx1) {
  28. _st(self._nodes())._add_(aNode);
  29. _st(aNode)._parent_(self);
  30. return self}, function($ctx1) {$ctx1.fill(self,"addNode:",{aNode:aNode},smalltalk.Node)})},
  31. args: ["aNode"],
  32. source: "addNode: aNode\x0a\x09self nodes add: aNode.\x0a\x09aNode parent: self",
  33. messageSends: ["add:", "nodes", "parent:"],
  34. referencedClasses: []
  35. }),
  36. smalltalk.Node);
  37. smalltalk.addMethod(
  38. smalltalk.method({
  39. selector: "isAssignmentNode",
  40. category: 'testing',
  41. fn: function (){
  42. var self=this;
  43. return smalltalk.withContext(function($ctx1) {
  44. return false;
  45. }, function($ctx1) {$ctx1.fill(self,"isAssignmentNode",{},smalltalk.Node)})},
  46. args: [],
  47. source: "isAssignmentNode\x0a\x09^ false",
  48. messageSends: [],
  49. referencedClasses: []
  50. }),
  51. smalltalk.Node);
  52. smalltalk.addMethod(
  53. smalltalk.method({
  54. selector: "isBlockNode",
  55. category: 'testing',
  56. fn: function (){
  57. var self=this;
  58. return smalltalk.withContext(function($ctx1) {
  59. return false;
  60. }, function($ctx1) {$ctx1.fill(self,"isBlockNode",{},smalltalk.Node)})},
  61. args: [],
  62. source: "isBlockNode\x0a\x09^false",
  63. messageSends: [],
  64. referencedClasses: []
  65. }),
  66. smalltalk.Node);
  67. smalltalk.addMethod(
  68. smalltalk.method({
  69. selector: "isBlockSequenceNode",
  70. category: 'testing',
  71. fn: function (){
  72. var self=this;
  73. return smalltalk.withContext(function($ctx1) {
  74. return false;
  75. }, function($ctx1) {$ctx1.fill(self,"isBlockSequenceNode",{},smalltalk.Node)})},
  76. args: [],
  77. source: "isBlockSequenceNode\x0a\x09^false",
  78. messageSends: [],
  79. referencedClasses: []
  80. }),
  81. smalltalk.Node);
  82. smalltalk.addMethod(
  83. smalltalk.method({
  84. selector: "isCascadeNode",
  85. category: 'testing',
  86. fn: function (){
  87. var self=this;
  88. return smalltalk.withContext(function($ctx1) {
  89. return false;
  90. }, function($ctx1) {$ctx1.fill(self,"isCascadeNode",{},smalltalk.Node)})},
  91. args: [],
  92. source: "isCascadeNode\x0a\x09^ false",
  93. messageSends: [],
  94. referencedClasses: []
  95. }),
  96. smalltalk.Node);
  97. smalltalk.addMethod(
  98. smalltalk.method({
  99. selector: "isImmutable",
  100. category: 'testing',
  101. fn: function (){
  102. var self=this;
  103. return smalltalk.withContext(function($ctx1) {
  104. return false;
  105. }, function($ctx1) {$ctx1.fill(self,"isImmutable",{},smalltalk.Node)})},
  106. args: [],
  107. source: "isImmutable\x0a\x09^false",
  108. messageSends: [],
  109. referencedClasses: []
  110. }),
  111. smalltalk.Node);
  112. smalltalk.addMethod(
  113. smalltalk.method({
  114. selector: "isJSStatementNode",
  115. category: 'testing',
  116. fn: function (){
  117. var self=this;
  118. return smalltalk.withContext(function($ctx1) {
  119. return false;
  120. }, function($ctx1) {$ctx1.fill(self,"isJSStatementNode",{},smalltalk.Node)})},
  121. args: [],
  122. source: "isJSStatementNode\x0a\x09^ false",
  123. messageSends: [],
  124. referencedClasses: []
  125. }),
  126. smalltalk.Node);
  127. smalltalk.addMethod(
  128. smalltalk.method({
  129. selector: "isLastChild",
  130. category: 'testing',
  131. fn: function (){
  132. var self=this;
  133. return smalltalk.withContext(function($ctx1) {
  134. var $1;
  135. $1=_st(_st(_st(self._parent())._nodes())._last()).__eq(self);
  136. return $1;
  137. }, function($ctx1) {$ctx1.fill(self,"isLastChild",{},smalltalk.Node)})},
  138. args: [],
  139. source: "isLastChild\x0a\x09^ self parent nodes last = self",
  140. messageSends: ["=", "last", "nodes", "parent"],
  141. referencedClasses: []
  142. }),
  143. smalltalk.Node);
  144. smalltalk.addMethod(
  145. smalltalk.method({
  146. selector: "isNode",
  147. category: 'testing',
  148. fn: function (){
  149. var self=this;
  150. return smalltalk.withContext(function($ctx1) {
  151. return true;
  152. }, function($ctx1) {$ctx1.fill(self,"isNode",{},smalltalk.Node)})},
  153. args: [],
  154. source: "isNode\x0a\x09^ true",
  155. messageSends: [],
  156. referencedClasses: []
  157. }),
  158. smalltalk.Node);
  159. smalltalk.addMethod(
  160. smalltalk.method({
  161. selector: "isReturnNode",
  162. category: 'testing',
  163. fn: function (){
  164. var self=this;
  165. return smalltalk.withContext(function($ctx1) {
  166. return false;
  167. }, function($ctx1) {$ctx1.fill(self,"isReturnNode",{},smalltalk.Node)})},
  168. args: [],
  169. source: "isReturnNode\x0a\x09^false",
  170. messageSends: [],
  171. referencedClasses: []
  172. }),
  173. smalltalk.Node);
  174. smalltalk.addMethod(
  175. smalltalk.method({
  176. selector: "isSendNode",
  177. category: 'testing',
  178. fn: function (){
  179. var self=this;
  180. return smalltalk.withContext(function($ctx1) {
  181. return false;
  182. }, function($ctx1) {$ctx1.fill(self,"isSendNode",{},smalltalk.Node)})},
  183. args: [],
  184. source: "isSendNode\x0a\x09^false",
  185. messageSends: [],
  186. referencedClasses: []
  187. }),
  188. smalltalk.Node);
  189. smalltalk.addMethod(
  190. smalltalk.method({
  191. selector: "isValueNode",
  192. category: 'testing',
  193. fn: function (){
  194. var self=this;
  195. return smalltalk.withContext(function($ctx1) {
  196. return false;
  197. }, function($ctx1) {$ctx1.fill(self,"isValueNode",{},smalltalk.Node)})},
  198. args: [],
  199. source: "isValueNode\x0a\x09^false",
  200. messageSends: [],
  201. referencedClasses: []
  202. }),
  203. smalltalk.Node);
  204. smalltalk.addMethod(
  205. smalltalk.method({
  206. selector: "nextChild",
  207. category: 'accessing',
  208. fn: function (){
  209. var self=this;
  210. return smalltalk.withContext(function($ctx1) {
  211. var $2,$1;
  212. $2=_st(self._nodes())._isEmpty();
  213. if(smalltalk.assert($2)){
  214. $1=self;
  215. } else {
  216. $1=_st(_st(self._nodes())._first())._nextChild();
  217. };
  218. return $1;
  219. }, function($ctx1) {$ctx1.fill(self,"nextChild",{},smalltalk.Node)})},
  220. args: [],
  221. source: "nextChild\x0a\x09\x22Answer the next node after aNode.\x0a\x09Recurse into the possible children of the receiver to answer the next node to be evaluated\x22\x0a\x09\x0a\x09^ self nodes isEmpty\x0a\x09\x09ifTrue: [ self ]\x0a\x09\x09ifFalse: [ self nodes first nextChild ]",
  222. messageSends: ["ifTrue:ifFalse:", "isEmpty", "nodes", "nextChild", "first"],
  223. referencedClasses: []
  224. }),
  225. smalltalk.Node);
  226. smalltalk.addMethod(
  227. smalltalk.method({
  228. selector: "nextNode",
  229. category: 'accessing',
  230. fn: function (){
  231. var self=this;
  232. return smalltalk.withContext(function($ctx1) {
  233. var $2,$1;
  234. $2=self._parent();
  235. if(($receiver = $2) == nil || $receiver == undefined){
  236. $1=$2;
  237. } else {
  238. var node;
  239. node=$receiver;
  240. $1=_st(node)._nextNode_(self);
  241. };
  242. return $1;
  243. }, function($ctx1) {$ctx1.fill(self,"nextNode",{},smalltalk.Node)})},
  244. args: [],
  245. source: "nextNode\x0a\x09^ self parent ifNotNil: [ :node |\x0a\x09\x09node nextNode: self ]",
  246. messageSends: ["ifNotNil:", "parent", "nextNode:"],
  247. referencedClasses: []
  248. }),
  249. smalltalk.Node);
  250. smalltalk.addMethod(
  251. smalltalk.method({
  252. selector: "nextNode:",
  253. category: 'accessing',
  254. fn: function (aNode){
  255. var self=this;
  256. var next;
  257. return smalltalk.withContext(function($ctx1) {
  258. var $1,$2;
  259. var $early={};
  260. try {
  261. next=_st(self._nodes())._at_ifAbsent_(_st(_st(self._nodes())._indexOf_(aNode)).__plus((1)),(function(){
  262. return smalltalk.withContext(function($ctx2) {
  263. $1=self;
  264. throw $early=[$1];
  265. }, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}));
  266. $2=_st(next)._nextChild();
  267. return $2;
  268. }
  269. catch(e) {if(e===$early)return e[0]; throw e}
  270. }, function($ctx1) {$ctx1.fill(self,"nextNode:",{aNode:aNode,next:next},smalltalk.Node)})},
  271. args: ["aNode"],
  272. source: "nextNode: aNode\x0a\x09\x22Answer the next node after aNode.\x0a\x09Recurse into the possible children of the next node to answer the next node to be evaluated\x22\x0a\x09\x0a\x09| next |\x0a\x09\x0a\x09next := self nodes \x0a\x09\x09at: (self nodes indexOf: aNode) + 1\x0a\x09\x09ifAbsent: [ ^ self ].\x0a\x09\x0a\x09^ next nextChild",
  273. messageSends: ["at:ifAbsent:", "nodes", "+", "indexOf:", "nextChild"],
  274. referencedClasses: []
  275. }),
  276. smalltalk.Node);
  277. smalltalk.addMethod(
  278. smalltalk.method({
  279. selector: "nodes",
  280. category: 'accessing',
  281. fn: function (){
  282. var self=this;
  283. function $Array(){return smalltalk.Array||(typeof Array=="undefined"?nil:Array)}
  284. return smalltalk.withContext(function($ctx1) {
  285. var $2,$1;
  286. $2=self["@nodes"];
  287. if(($receiver = $2) == nil || $receiver == undefined){
  288. self["@nodes"]=_st($Array())._new();
  289. $1=self["@nodes"];
  290. } else {
  291. $1=$2;
  292. };
  293. return $1;
  294. }, function($ctx1) {$ctx1.fill(self,"nodes",{},smalltalk.Node)})},
  295. args: [],
  296. source: "nodes\x0a\x09^nodes ifNil: [nodes := Array new]",
  297. messageSends: ["ifNil:", "new"],
  298. referencedClasses: ["Array"]
  299. }),
  300. smalltalk.Node);
  301. smalltalk.addMethod(
  302. smalltalk.method({
  303. selector: "nodes:",
  304. category: 'building',
  305. fn: function (aCollection){
  306. var self=this;
  307. return smalltalk.withContext(function($ctx1) {
  308. self["@nodes"]=aCollection;
  309. _st(aCollection)._do_((function(each){
  310. return smalltalk.withContext(function($ctx2) {
  311. return _st(each)._parent_(self);
  312. }, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1,1)})}));
  313. return self}, function($ctx1) {$ctx1.fill(self,"nodes:",{aCollection:aCollection},smalltalk.Node)})},
  314. args: ["aCollection"],
  315. source: "nodes: aCollection\x0a\x09nodes := aCollection.\x0a\x09aCollection do: [ :each | each parent: self ]",
  316. messageSends: ["do:", "parent:"],
  317. referencedClasses: []
  318. }),
  319. smalltalk.Node);
  320. smalltalk.addMethod(
  321. smalltalk.method({
  322. selector: "parent",
  323. category: 'accessing',
  324. fn: function (){
  325. var self=this;
  326. return smalltalk.withContext(function($ctx1) {
  327. var $1;
  328. $1=self["@parent"];
  329. return $1;
  330. }, function($ctx1) {$ctx1.fill(self,"parent",{},smalltalk.Node)})},
  331. args: [],
  332. source: "parent\x0a\x09^ parent",
  333. messageSends: [],
  334. referencedClasses: []
  335. }),
  336. smalltalk.Node);
  337. smalltalk.addMethod(
  338. smalltalk.method({
  339. selector: "parent:",
  340. category: 'accessing',
  341. fn: function (aNode){
  342. var self=this;
  343. return smalltalk.withContext(function($ctx1) {
  344. self["@parent"]=aNode;
  345. return self}, function($ctx1) {$ctx1.fill(self,"parent:",{aNode:aNode},smalltalk.Node)})},
  346. args: ["aNode"],
  347. source: "parent: aNode\x0a\x09parent := aNode",
  348. messageSends: [],
  349. referencedClasses: []
  350. }),
  351. smalltalk.Node);
  352. smalltalk.addMethod(
  353. smalltalk.method({
  354. selector: "position",
  355. category: 'accessing',
  356. fn: function (){
  357. var self=this;
  358. return smalltalk.withContext(function($ctx1) {
  359. var $2,$3,$1;
  360. $2=self["@position"];
  361. if(($receiver = $2) == nil || $receiver == undefined){
  362. $3=self._parent();
  363. if(($receiver = $3) == nil || $receiver == undefined){
  364. $1=$3;
  365. } else {
  366. var node;
  367. node=$receiver;
  368. $1=_st(node)._position();
  369. };
  370. } else {
  371. $1=$2;
  372. };
  373. return $1;
  374. }, function($ctx1) {$ctx1.fill(self,"position",{},smalltalk.Node)})},
  375. args: [],
  376. source: "position\x0a\x09\x22answer the line and column of the receiver in the source code\x22\x0a\x09\x0a\x09^ position ifNil: [ \x0a\x09\x09self parent ifNotNil: [ :node | node position ] ]",
  377. messageSends: ["ifNil:", "ifNotNil:", "parent", "position"],
  378. referencedClasses: []
  379. }),
  380. smalltalk.Node);
  381. smalltalk.addMethod(
  382. smalltalk.method({
  383. selector: "position:",
  384. category: 'building',
  385. fn: function (aPosition){
  386. var self=this;
  387. return smalltalk.withContext(function($ctx1) {
  388. self["@position"]=aPosition;
  389. return self}, function($ctx1) {$ctx1.fill(self,"position:",{aPosition:aPosition},smalltalk.Node)})},
  390. args: ["aPosition"],
  391. source: "position: aPosition\x0a\x09position := aPosition",
  392. messageSends: [],
  393. referencedClasses: []
  394. }),
  395. smalltalk.Node);
  396. smalltalk.addMethod(
  397. smalltalk.method({
  398. selector: "postCopy",
  399. category: 'copying',
  400. fn: function (){
  401. var self=this;
  402. return smalltalk.withContext(function($ctx1) {
  403. smalltalk.Object.fn.prototype._postCopy.apply(_st(self), []);
  404. _st(self._nodes())._do_((function(each){
  405. return smalltalk.withContext(function($ctx2) {
  406. return _st(each)._parent_(self);
  407. }, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1,1)})}));
  408. return self}, function($ctx1) {$ctx1.fill(self,"postCopy",{},smalltalk.Node)})},
  409. args: [],
  410. source: "postCopy\x0a\x09super postCopy.\x0a\x09self nodes do: [ :each | each parent: self ]",
  411. messageSends: ["postCopy", "do:", "nodes", "parent:"],
  412. referencedClasses: []
  413. }),
  414. smalltalk.Node);
  415. smalltalk.addMethod(
  416. smalltalk.method({
  417. selector: "shouldBeAliased",
  418. category: 'accessing',
  419. fn: function (){
  420. var self=this;
  421. return smalltalk.withContext(function($ctx1) {
  422. var $2,$1;
  423. $2=self["@shouldBeAliased"];
  424. if(($receiver = $2) == nil || $receiver == undefined){
  425. $1=false;
  426. } else {
  427. $1=$2;
  428. };
  429. return $1;
  430. }, function($ctx1) {$ctx1.fill(self,"shouldBeAliased",{},smalltalk.Node)})},
  431. args: [],
  432. source: "shouldBeAliased\x0a\x09^ shouldBeAliased ifNil: [ false ]",
  433. messageSends: ["ifNil:"],
  434. referencedClasses: []
  435. }),
  436. smalltalk.Node);
  437. smalltalk.addMethod(
  438. smalltalk.method({
  439. selector: "shouldBeAliased:",
  440. category: 'accessing',
  441. fn: function (aBoolean){
  442. var self=this;
  443. return smalltalk.withContext(function($ctx1) {
  444. self["@shouldBeAliased"]=aBoolean;
  445. return self}, function($ctx1) {$ctx1.fill(self,"shouldBeAliased:",{aBoolean:aBoolean},smalltalk.Node)})},
  446. args: ["aBoolean"],
  447. source: "shouldBeAliased: aBoolean\x0a\x09shouldBeAliased := aBoolean",
  448. messageSends: [],
  449. referencedClasses: []
  450. }),
  451. smalltalk.Node);
  452. smalltalk.addMethod(
  453. smalltalk.method({
  454. selector: "shouldBeInlined",
  455. category: 'accessing',
  456. fn: function (){
  457. var self=this;
  458. return smalltalk.withContext(function($ctx1) {
  459. var $2,$1;
  460. $2=self["@shouldBeInlined"];
  461. if(($receiver = $2) == nil || $receiver == undefined){
  462. $1=false;
  463. } else {
  464. $1=$2;
  465. };
  466. return $1;
  467. }, function($ctx1) {$ctx1.fill(self,"shouldBeInlined",{},smalltalk.Node)})},
  468. args: [],
  469. source: "shouldBeInlined\x0a\x09^ shouldBeInlined ifNil: [ false ]",
  470. messageSends: ["ifNil:"],
  471. referencedClasses: []
  472. }),
  473. smalltalk.Node);
  474. smalltalk.addMethod(
  475. smalltalk.method({
  476. selector: "shouldBeInlined:",
  477. category: 'accessing',
  478. fn: function (aBoolean){
  479. var self=this;
  480. return smalltalk.withContext(function($ctx1) {
  481. self["@shouldBeInlined"]=aBoolean;
  482. return self}, function($ctx1) {$ctx1.fill(self,"shouldBeInlined:",{aBoolean:aBoolean},smalltalk.Node)})},
  483. args: ["aBoolean"],
  484. source: "shouldBeInlined: aBoolean\x0a\x09shouldBeInlined := aBoolean",
  485. messageSends: [],
  486. referencedClasses: []
  487. }),
  488. smalltalk.Node);
  489. smalltalk.addMethod(
  490. smalltalk.method({
  491. selector: "stopOnStepping",
  492. category: 'testing',
  493. fn: function (){
  494. var self=this;
  495. return smalltalk.withContext(function($ctx1) {
  496. return false;
  497. }, function($ctx1) {$ctx1.fill(self,"stopOnStepping",{},smalltalk.Node)})},
  498. args: [],
  499. source: "stopOnStepping\x0a\x09^ false",
  500. messageSends: [],
  501. referencedClasses: []
  502. }),
  503. smalltalk.Node);
  504. smalltalk.addMethod(
  505. smalltalk.method({
  506. selector: "subtreeNeedsAliasing",
  507. category: 'testing',
  508. fn: function (){
  509. var self=this;
  510. return smalltalk.withContext(function($ctx1) {
  511. var $1;
  512. $1=_st(_st(self._shouldBeAliased())._or_((function(){
  513. return smalltalk.withContext(function($ctx2) {
  514. return self._shouldBeInlined();
  515. }, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})})))._or_((function(){
  516. return smalltalk.withContext(function($ctx2) {
  517. return _st(_st(self._nodes())._detect_ifNone_((function(each){
  518. return smalltalk.withContext(function($ctx3) {
  519. return _st(each)._subtreeNeedsAliasing();
  520. }, function($ctx3) {$ctx3.fillBlock({each:each},$ctx2,3)})}),(function(){
  521. return smalltalk.withContext(function($ctx3) {
  522. return false;
  523. }, function($ctx3) {$ctx3.fillBlock({},$ctx2,4)})}))).__tild_eq(false);
  524. }, function($ctx2) {$ctx2.fillBlock({},$ctx1,2)})}));
  525. return $1;
  526. }, function($ctx1) {$ctx1.fill(self,"subtreeNeedsAliasing",{},smalltalk.Node)})},
  527. args: [],
  528. source: "subtreeNeedsAliasing\x0a\x09^(self shouldBeAliased or: [ self shouldBeInlined ]) or: [\x0a\x09\x09(self nodes detect: [ :each | each subtreeNeedsAliasing ] ifNone: [ false ]) ~= false ]",
  529. messageSends: ["or:", "shouldBeAliased", "shouldBeInlined", "~=", "detect:ifNone:", "nodes", "subtreeNeedsAliasing"],
  530. referencedClasses: []
  531. }),
  532. smalltalk.Node);
  533. smalltalk.addClass('AssignmentNode', smalltalk.Node, ['left', 'right'], 'Compiler-AST');
  534. smalltalk.AssignmentNode.comment="I represent an assignment node.";
  535. smalltalk.addMethod(
  536. smalltalk.method({
  537. selector: "accept:",
  538. category: 'visiting',
  539. fn: function (aVisitor){
  540. var self=this;
  541. return smalltalk.withContext(function($ctx1) {
  542. var $1;
  543. $1=_st(aVisitor)._visitAssignmentNode_(self);
  544. return $1;
  545. }, function($ctx1) {$ctx1.fill(self,"accept:",{aVisitor:aVisitor},smalltalk.AssignmentNode)})},
  546. args: ["aVisitor"],
  547. source: "accept: aVisitor\x0a\x09^ aVisitor visitAssignmentNode: self",
  548. messageSends: ["visitAssignmentNode:"],
  549. referencedClasses: []
  550. }),
  551. smalltalk.AssignmentNode);
  552. smalltalk.addMethod(
  553. smalltalk.method({
  554. selector: "isAssignmentNode",
  555. category: 'testing',
  556. fn: function (){
  557. var self=this;
  558. return smalltalk.withContext(function($ctx1) {
  559. return true;
  560. }, function($ctx1) {$ctx1.fill(self,"isAssignmentNode",{},smalltalk.AssignmentNode)})},
  561. args: [],
  562. source: "isAssignmentNode\x0a\x09^ true",
  563. messageSends: [],
  564. referencedClasses: []
  565. }),
  566. smalltalk.AssignmentNode);
  567. smalltalk.addMethod(
  568. smalltalk.method({
  569. selector: "left",
  570. category: 'accessing',
  571. fn: function (){
  572. var self=this;
  573. return smalltalk.withContext(function($ctx1) {
  574. var $1;
  575. $1=self["@left"];
  576. return $1;
  577. }, function($ctx1) {$ctx1.fill(self,"left",{},smalltalk.AssignmentNode)})},
  578. args: [],
  579. source: "left\x0a\x09^left",
  580. messageSends: [],
  581. referencedClasses: []
  582. }),
  583. smalltalk.AssignmentNode);
  584. smalltalk.addMethod(
  585. smalltalk.method({
  586. selector: "left:",
  587. category: 'accessing',
  588. fn: function (aNode){
  589. var self=this;
  590. return smalltalk.withContext(function($ctx1) {
  591. self["@left"]=aNode;
  592. _st(aNode)._parent_(self);
  593. return self}, function($ctx1) {$ctx1.fill(self,"left:",{aNode:aNode},smalltalk.AssignmentNode)})},
  594. args: ["aNode"],
  595. source: "left: aNode\x0a\x09left := aNode.\x0a\x09aNode parent: self",
  596. messageSends: ["parent:"],
  597. referencedClasses: []
  598. }),
  599. smalltalk.AssignmentNode);
  600. smalltalk.addMethod(
  601. smalltalk.method({
  602. selector: "nodes",
  603. category: 'accessing',
  604. fn: function (){
  605. var self=this;
  606. function $Array(){return smalltalk.Array||(typeof Array=="undefined"?nil:Array)}
  607. return smalltalk.withContext(function($ctx1) {
  608. var $1;
  609. $1=_st($Array())._with_with_(self._left(),self._right());
  610. return $1;
  611. }, function($ctx1) {$ctx1.fill(self,"nodes",{},smalltalk.AssignmentNode)})},
  612. args: [],
  613. source: "nodes\x0a\x09^ Array with: self left with: self right",
  614. messageSends: ["with:with:", "left", "right"],
  615. referencedClasses: ["Array"]
  616. }),
  617. smalltalk.AssignmentNode);
  618. smalltalk.addMethod(
  619. smalltalk.method({
  620. selector: "right",
  621. category: 'accessing',
  622. fn: function (){
  623. var self=this;
  624. return smalltalk.withContext(function($ctx1) {
  625. var $1;
  626. $1=self["@right"];
  627. return $1;
  628. }, function($ctx1) {$ctx1.fill(self,"right",{},smalltalk.AssignmentNode)})},
  629. args: [],
  630. source: "right\x0a\x09^right",
  631. messageSends: [],
  632. referencedClasses: []
  633. }),
  634. smalltalk.AssignmentNode);
  635. smalltalk.addMethod(
  636. smalltalk.method({
  637. selector: "right:",
  638. category: 'accessing',
  639. fn: function (aNode){
  640. var self=this;
  641. return smalltalk.withContext(function($ctx1) {
  642. self["@right"]=aNode;
  643. _st(aNode)._parent_(self);
  644. return self}, function($ctx1) {$ctx1.fill(self,"right:",{aNode:aNode},smalltalk.AssignmentNode)})},
  645. args: ["aNode"],
  646. source: "right: aNode\x0a\x09right := aNode.\x0a\x09aNode parent: self",
  647. messageSends: ["parent:"],
  648. referencedClasses: []
  649. }),
  650. smalltalk.AssignmentNode);
  651. smalltalk.addClass('BlockNode', smalltalk.Node, ['parameters', 'scope'], 'Compiler-AST');
  652. smalltalk.BlockNode.comment="I represent an block closure node.";
  653. smalltalk.addMethod(
  654. smalltalk.method({
  655. selector: "accept:",
  656. category: 'visiting',
  657. fn: function (aVisitor){
  658. var self=this;
  659. return smalltalk.withContext(function($ctx1) {
  660. var $1;
  661. $1=_st(aVisitor)._visitBlockNode_(self);
  662. return $1;
  663. }, function($ctx1) {$ctx1.fill(self,"accept:",{aVisitor:aVisitor},smalltalk.BlockNode)})},
  664. args: ["aVisitor"],
  665. source: "accept: aVisitor\x0a\x09^ aVisitor visitBlockNode: self",
  666. messageSends: ["visitBlockNode:"],
  667. referencedClasses: []
  668. }),
  669. smalltalk.BlockNode);
  670. smalltalk.addMethod(
  671. smalltalk.method({
  672. selector: "isBlockNode",
  673. category: 'testing',
  674. fn: function (){
  675. var self=this;
  676. return smalltalk.withContext(function($ctx1) {
  677. return true;
  678. }, function($ctx1) {$ctx1.fill(self,"isBlockNode",{},smalltalk.BlockNode)})},
  679. args: [],
  680. source: "isBlockNode\x0a\x09^true",
  681. messageSends: [],
  682. referencedClasses: []
  683. }),
  684. smalltalk.BlockNode);
  685. smalltalk.addMethod(
  686. smalltalk.method({
  687. selector: "nextChild",
  688. category: 'accessing',
  689. fn: function (){
  690. var self=this;
  691. return smalltalk.withContext(function($ctx1) {
  692. var $1;
  693. $1=self;
  694. return $1;
  695. }, function($ctx1) {$ctx1.fill(self,"nextChild",{},smalltalk.BlockNode)})},
  696. args: [],
  697. source: "nextChild\x0a\x09\x22Answer the receiver as we want to avoid eager evaluation\x22\x0a\x09\x0a\x09^ self",
  698. messageSends: [],
  699. referencedClasses: []
  700. }),
  701. smalltalk.BlockNode);
  702. smalltalk.addMethod(
  703. smalltalk.method({
  704. selector: "nextNode:",
  705. category: 'accessing',
  706. fn: function (aNode){
  707. var self=this;
  708. return smalltalk.withContext(function($ctx1) {
  709. var $1;
  710. $1=self;
  711. return $1;
  712. }, function($ctx1) {$ctx1.fill(self,"nextNode:",{aNode:aNode},smalltalk.BlockNode)})},
  713. args: ["aNode"],
  714. source: "nextNode: aNode\x0a\x09\x22Answer the receiver as we want to avoid eager evaluation\x22\x0a\x09\x0a\x09^ self",
  715. messageSends: [],
  716. referencedClasses: []
  717. }),
  718. smalltalk.BlockNode);
  719. smalltalk.addMethod(
  720. smalltalk.method({
  721. selector: "parameters",
  722. category: 'accessing',
  723. fn: function (){
  724. var self=this;
  725. function $Array(){return smalltalk.Array||(typeof Array=="undefined"?nil:Array)}
  726. return smalltalk.withContext(function($ctx1) {
  727. var $2,$1;
  728. $2=self["@parameters"];
  729. if(($receiver = $2) == nil || $receiver == undefined){
  730. self["@parameters"]=_st($Array())._new();
  731. $1=self["@parameters"];
  732. } else {
  733. $1=$2;
  734. };
  735. return $1;
  736. }, function($ctx1) {$ctx1.fill(self,"parameters",{},smalltalk.BlockNode)})},
  737. args: [],
  738. source: "parameters\x0a\x09^parameters ifNil: [parameters := Array new]",
  739. messageSends: ["ifNil:", "new"],
  740. referencedClasses: ["Array"]
  741. }),
  742. smalltalk.BlockNode);
  743. smalltalk.addMethod(
  744. smalltalk.method({
  745. selector: "parameters:",
  746. category: 'accessing',
  747. fn: function (aCollection){
  748. var self=this;
  749. return smalltalk.withContext(function($ctx1) {
  750. self["@parameters"]=aCollection;
  751. return self}, function($ctx1) {$ctx1.fill(self,"parameters:",{aCollection:aCollection},smalltalk.BlockNode)})},
  752. args: ["aCollection"],
  753. source: "parameters: aCollection\x0a\x09parameters := aCollection",
  754. messageSends: [],
  755. referencedClasses: []
  756. }),
  757. smalltalk.BlockNode);
  758. smalltalk.addMethod(
  759. smalltalk.method({
  760. selector: "scope",
  761. category: 'accessing',
  762. fn: function (){
  763. var self=this;
  764. return smalltalk.withContext(function($ctx1) {
  765. var $1;
  766. $1=self["@scope"];
  767. return $1;
  768. }, function($ctx1) {$ctx1.fill(self,"scope",{},smalltalk.BlockNode)})},
  769. args: [],
  770. source: "scope\x0a\x09^ scope",
  771. messageSends: [],
  772. referencedClasses: []
  773. }),
  774. smalltalk.BlockNode);
  775. smalltalk.addMethod(
  776. smalltalk.method({
  777. selector: "scope:",
  778. category: 'accessing',
  779. fn: function (aLexicalScope){
  780. var self=this;
  781. return smalltalk.withContext(function($ctx1) {
  782. self["@scope"]=aLexicalScope;
  783. return self}, function($ctx1) {$ctx1.fill(self,"scope:",{aLexicalScope:aLexicalScope},smalltalk.BlockNode)})},
  784. args: ["aLexicalScope"],
  785. source: "scope: aLexicalScope\x0a\x09scope := aLexicalScope",
  786. messageSends: [],
  787. referencedClasses: []
  788. }),
  789. smalltalk.BlockNode);
  790. smalltalk.addMethod(
  791. smalltalk.method({
  792. selector: "subtreeNeedsAliasing",
  793. category: 'testing',
  794. fn: function (){
  795. var self=this;
  796. return smalltalk.withContext(function($ctx1) {
  797. var $1;
  798. $1=_st(self._shouldBeAliased())._or_((function(){
  799. return smalltalk.withContext(function($ctx2) {
  800. return self._shouldBeInlined();
  801. }, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}));
  802. return $1;
  803. }, function($ctx1) {$ctx1.fill(self,"subtreeNeedsAliasing",{},smalltalk.BlockNode)})},
  804. args: [],
  805. source: "subtreeNeedsAliasing\x0a\x09^ self shouldBeAliased or: [ self shouldBeInlined ]",
  806. messageSends: ["or:", "shouldBeAliased", "shouldBeInlined"],
  807. referencedClasses: []
  808. }),
  809. smalltalk.BlockNode);
  810. smalltalk.addClass('CascadeNode', smalltalk.Node, ['receiver'], 'Compiler-AST');
  811. smalltalk.CascadeNode.comment="I represent an cascade node.";
  812. smalltalk.addMethod(
  813. smalltalk.method({
  814. selector: "accept:",
  815. category: 'visiting',
  816. fn: function (aVisitor){
  817. var self=this;
  818. return smalltalk.withContext(function($ctx1) {
  819. var $1;
  820. $1=_st(aVisitor)._visitCascadeNode_(self);
  821. return $1;
  822. }, function($ctx1) {$ctx1.fill(self,"accept:",{aVisitor:aVisitor},smalltalk.CascadeNode)})},
  823. args: ["aVisitor"],
  824. source: "accept: aVisitor\x0a\x09^ aVisitor visitCascadeNode: self",
  825. messageSends: ["visitCascadeNode:"],
  826. referencedClasses: []
  827. }),
  828. smalltalk.CascadeNode);
  829. smalltalk.addMethod(
  830. smalltalk.method({
  831. selector: "isCascadeNode",
  832. category: 'testing',
  833. fn: function (){
  834. var self=this;
  835. return smalltalk.withContext(function($ctx1) {
  836. return true;
  837. }, function($ctx1) {$ctx1.fill(self,"isCascadeNode",{},smalltalk.CascadeNode)})},
  838. args: [],
  839. source: "isCascadeNode\x0a\x09^ true",
  840. messageSends: [],
  841. referencedClasses: []
  842. }),
  843. smalltalk.CascadeNode);
  844. smalltalk.addMethod(
  845. smalltalk.method({
  846. selector: "receiver",
  847. category: 'accessing',
  848. fn: function (){
  849. var self=this;
  850. return smalltalk.withContext(function($ctx1) {
  851. var $1;
  852. $1=self["@receiver"];
  853. return $1;
  854. }, function($ctx1) {$ctx1.fill(self,"receiver",{},smalltalk.CascadeNode)})},
  855. args: [],
  856. source: "receiver\x0a\x09^receiver",
  857. messageSends: [],
  858. referencedClasses: []
  859. }),
  860. smalltalk.CascadeNode);
  861. smalltalk.addMethod(
  862. smalltalk.method({
  863. selector: "receiver:",
  864. category: 'accessing',
  865. fn: function (aNode){
  866. var self=this;
  867. return smalltalk.withContext(function($ctx1) {
  868. self["@receiver"]=aNode;
  869. return self}, function($ctx1) {$ctx1.fill(self,"receiver:",{aNode:aNode},smalltalk.CascadeNode)})},
  870. args: ["aNode"],
  871. source: "receiver: aNode\x0a\x09receiver := aNode",
  872. messageSends: [],
  873. referencedClasses: []
  874. }),
  875. smalltalk.CascadeNode);
  876. smalltalk.addClass('DynamicArrayNode', smalltalk.Node, [], 'Compiler-AST');
  877. smalltalk.DynamicArrayNode.comment="I represent an dynamic array node.";
  878. smalltalk.addMethod(
  879. smalltalk.method({
  880. selector: "accept:",
  881. category: 'visiting',
  882. fn: function (aVisitor){
  883. var self=this;
  884. return smalltalk.withContext(function($ctx1) {
  885. var $1;
  886. $1=_st(aVisitor)._visitDynamicArrayNode_(self);
  887. return $1;
  888. }, function($ctx1) {$ctx1.fill(self,"accept:",{aVisitor:aVisitor},smalltalk.DynamicArrayNode)})},
  889. args: ["aVisitor"],
  890. source: "accept: aVisitor\x0a\x09^ aVisitor visitDynamicArrayNode: self",
  891. messageSends: ["visitDynamicArrayNode:"],
  892. referencedClasses: []
  893. }),
  894. smalltalk.DynamicArrayNode);
  895. smalltalk.addClass('DynamicDictionaryNode', smalltalk.Node, [], 'Compiler-AST');
  896. smalltalk.DynamicDictionaryNode.comment="I represent an dynamic dictionary node.";
  897. smalltalk.addMethod(
  898. smalltalk.method({
  899. selector: "accept:",
  900. category: 'visiting',
  901. fn: function (aVisitor){
  902. var self=this;
  903. return smalltalk.withContext(function($ctx1) {
  904. var $1;
  905. $1=_st(aVisitor)._visitDynamicDictionaryNode_(self);
  906. return $1;
  907. }, function($ctx1) {$ctx1.fill(self,"accept:",{aVisitor:aVisitor},smalltalk.DynamicDictionaryNode)})},
  908. args: ["aVisitor"],
  909. source: "accept: aVisitor\x0a\x09^ aVisitor visitDynamicDictionaryNode: self",
  910. messageSends: ["visitDynamicDictionaryNode:"],
  911. referencedClasses: []
  912. }),
  913. smalltalk.DynamicDictionaryNode);
  914. smalltalk.addClass('JSStatementNode', smalltalk.Node, ['source'], 'Compiler-AST');
  915. smalltalk.JSStatementNode.comment="I represent an JavaScript statement node.";
  916. smalltalk.addMethod(
  917. smalltalk.method({
  918. selector: "accept:",
  919. category: 'visiting',
  920. fn: function (aVisitor){
  921. var self=this;
  922. return smalltalk.withContext(function($ctx1) {
  923. var $1;
  924. $1=_st(aVisitor)._visitJSStatementNode_(self);
  925. return $1;
  926. }, function($ctx1) {$ctx1.fill(self,"accept:",{aVisitor:aVisitor},smalltalk.JSStatementNode)})},
  927. args: ["aVisitor"],
  928. source: "accept: aVisitor\x0a\x09^ aVisitor visitJSStatementNode: self",
  929. messageSends: ["visitJSStatementNode:"],
  930. referencedClasses: []
  931. }),
  932. smalltalk.JSStatementNode);
  933. smalltalk.addMethod(
  934. smalltalk.method({
  935. selector: "isJSStatementNode",
  936. category: 'testing',
  937. fn: function (){
  938. var self=this;
  939. return smalltalk.withContext(function($ctx1) {
  940. return true;
  941. }, function($ctx1) {$ctx1.fill(self,"isJSStatementNode",{},smalltalk.JSStatementNode)})},
  942. args: [],
  943. source: "isJSStatementNode\x0a\x09^ true",
  944. messageSends: [],
  945. referencedClasses: []
  946. }),
  947. smalltalk.JSStatementNode);
  948. smalltalk.addMethod(
  949. smalltalk.method({
  950. selector: "source",
  951. category: 'accessing',
  952. fn: function (){
  953. var self=this;
  954. return smalltalk.withContext(function($ctx1) {
  955. var $2,$1;
  956. $2=self["@source"];
  957. if(($receiver = $2) == nil || $receiver == undefined){
  958. $1="";
  959. } else {
  960. $1=$2;
  961. };
  962. return $1;
  963. }, function($ctx1) {$ctx1.fill(self,"source",{},smalltalk.JSStatementNode)})},
  964. args: [],
  965. source: "source\x0a\x09^source ifNil: ['']",
  966. messageSends: ["ifNil:"],
  967. referencedClasses: []
  968. }),
  969. smalltalk.JSStatementNode);
  970. smalltalk.addMethod(
  971. smalltalk.method({
  972. selector: "source:",
  973. category: 'accessing',
  974. fn: function (aString){
  975. var self=this;
  976. return smalltalk.withContext(function($ctx1) {
  977. self["@source"]=aString;
  978. return self}, function($ctx1) {$ctx1.fill(self,"source:",{aString:aString},smalltalk.JSStatementNode)})},
  979. args: ["aString"],
  980. source: "source: aString\x0a\x09source := aString",
  981. messageSends: [],
  982. referencedClasses: []
  983. }),
  984. smalltalk.JSStatementNode);
  985. smalltalk.addClass('MethodNode', smalltalk.Node, ['selector', 'arguments', 'source', 'scope', 'classReferences', 'messageSends', 'superSends'], 'Compiler-AST');
  986. smalltalk.MethodNode.comment="I represent an method node.\x0a\x0aA method node must be the root and only method node of a valid AST.";
  987. smalltalk.addMethod(
  988. smalltalk.method({
  989. selector: "accept:",
  990. category: 'visiting',
  991. fn: function (aVisitor){
  992. var self=this;
  993. return smalltalk.withContext(function($ctx1) {
  994. var $1;
  995. $1=_st(aVisitor)._visitMethodNode_(self);
  996. return $1;
  997. }, function($ctx1) {$ctx1.fill(self,"accept:",{aVisitor:aVisitor},smalltalk.MethodNode)})},
  998. args: ["aVisitor"],
  999. source: "accept: aVisitor\x0a\x09^ aVisitor visitMethodNode: self",
  1000. messageSends: ["visitMethodNode:"],
  1001. referencedClasses: []
  1002. }),
  1003. smalltalk.MethodNode);
  1004. smalltalk.addMethod(
  1005. smalltalk.method({
  1006. selector: "arguments",
  1007. category: 'accessing',
  1008. fn: function (){
  1009. var self=this;
  1010. return smalltalk.withContext(function($ctx1) {
  1011. var $2,$1;
  1012. $2=self["@arguments"];
  1013. if(($receiver = $2) == nil || $receiver == undefined){
  1014. $1=[];
  1015. } else {
  1016. $1=$2;
  1017. };
  1018. return $1;
  1019. }, function($ctx1) {$ctx1.fill(self,"arguments",{},smalltalk.MethodNode)})},
  1020. args: [],
  1021. source: "arguments\x0a\x09^arguments ifNil: [#()]",
  1022. messageSends: ["ifNil:"],
  1023. referencedClasses: []
  1024. }),
  1025. smalltalk.MethodNode);
  1026. smalltalk.addMethod(
  1027. smalltalk.method({
  1028. selector: "arguments:",
  1029. category: 'accessing',
  1030. fn: function (aCollection){
  1031. var self=this;
  1032. return smalltalk.withContext(function($ctx1) {
  1033. self["@arguments"]=aCollection;
  1034. return self}, function($ctx1) {$ctx1.fill(self,"arguments:",{aCollection:aCollection},smalltalk.MethodNode)})},
  1035. args: ["aCollection"],
  1036. source: "arguments: aCollection\x0a\x09arguments := aCollection",
  1037. messageSends: [],
  1038. referencedClasses: []
  1039. }),
  1040. smalltalk.MethodNode);
  1041. smalltalk.addMethod(
  1042. smalltalk.method({
  1043. selector: "classReferences",
  1044. category: 'accessing',
  1045. fn: function (){
  1046. var self=this;
  1047. return smalltalk.withContext(function($ctx1) {
  1048. var $1;
  1049. $1=self["@classReferences"];
  1050. return $1;
  1051. }, function($ctx1) {$ctx1.fill(self,"classReferences",{},smalltalk.MethodNode)})},
  1052. args: [],
  1053. source: "classReferences\x0a\x09^ classReferences",
  1054. messageSends: [],
  1055. referencedClasses: []
  1056. }),
  1057. smalltalk.MethodNode);
  1058. smalltalk.addMethod(
  1059. smalltalk.method({
  1060. selector: "classReferences:",
  1061. category: 'accessing',
  1062. fn: function (aCollection){
  1063. var self=this;
  1064. return smalltalk.withContext(function($ctx1) {
  1065. self["@classReferences"]=aCollection;
  1066. return self}, function($ctx1) {$ctx1.fill(self,"classReferences:",{aCollection:aCollection},smalltalk.MethodNode)})},
  1067. args: ["aCollection"],
  1068. source: "classReferences: aCollection\x0a\x09classReferences := aCollection",
  1069. messageSends: [],
  1070. referencedClasses: []
  1071. }),
  1072. smalltalk.MethodNode);
  1073. smalltalk.addMethod(
  1074. smalltalk.method({
  1075. selector: "extent",
  1076. category: 'accessing',
  1077. fn: function (){
  1078. var self=this;
  1079. return smalltalk.withContext(function($ctx1) {
  1080. var $1;
  1081. $1=_st(_st(_st(self._source())._lines())._size()).__at(_st(_st(_st(_st(self._source())._lines())._last())._size()).__plus((1)));
  1082. return $1;
  1083. }, function($ctx1) {$ctx1.fill(self,"extent",{},smalltalk.MethodNode)})},
  1084. args: [],
  1085. source: "extent\x0a\x09^ self source lines size @ (self source lines last size + 1)",
  1086. messageSends: ["@", "size", "lines", "source", "+", "last"],
  1087. referencedClasses: []
  1088. }),
  1089. smalltalk.MethodNode);
  1090. smalltalk.addMethod(
  1091. smalltalk.method({
  1092. selector: "messageSends",
  1093. category: 'accessing',
  1094. fn: function (){
  1095. var self=this;
  1096. return smalltalk.withContext(function($ctx1) {
  1097. var $1;
  1098. $1=self["@messageSends"];
  1099. return $1;
  1100. }, function($ctx1) {$ctx1.fill(self,"messageSends",{},smalltalk.MethodNode)})},
  1101. args: [],
  1102. source: "messageSends\x0a\x09^ messageSends",
  1103. messageSends: [],
  1104. referencedClasses: []
  1105. }),
  1106. smalltalk.MethodNode);
  1107. smalltalk.addMethod(
  1108. smalltalk.method({
  1109. selector: "messageSends:",
  1110. category: 'accessing',
  1111. fn: function (aCollection){
  1112. var self=this;
  1113. return smalltalk.withContext(function($ctx1) {
  1114. self["@messageSends"]=aCollection;
  1115. return self}, function($ctx1) {$ctx1.fill(self,"messageSends:",{aCollection:aCollection},smalltalk.MethodNode)})},
  1116. args: ["aCollection"],
  1117. source: "messageSends: aCollection\x0a\x09messageSends := aCollection",
  1118. messageSends: [],
  1119. referencedClasses: []
  1120. }),
  1121. smalltalk.MethodNode);
  1122. smalltalk.addMethod(
  1123. smalltalk.method({
  1124. selector: "scope",
  1125. category: 'accessing',
  1126. fn: function (){
  1127. var self=this;
  1128. return smalltalk.withContext(function($ctx1) {
  1129. var $1;
  1130. $1=self["@scope"];
  1131. return $1;
  1132. }, function($ctx1) {$ctx1.fill(self,"scope",{},smalltalk.MethodNode)})},
  1133. args: [],
  1134. source: "scope\x0a\x09^ scope",
  1135. messageSends: [],
  1136. referencedClasses: []
  1137. }),
  1138. smalltalk.MethodNode);
  1139. smalltalk.addMethod(
  1140. smalltalk.method({
  1141. selector: "scope:",
  1142. category: 'accessing',
  1143. fn: function (aMethodScope){
  1144. var self=this;
  1145. return smalltalk.withContext(function($ctx1) {
  1146. self["@scope"]=aMethodScope;
  1147. return self}, function($ctx1) {$ctx1.fill(self,"scope:",{aMethodScope:aMethodScope},smalltalk.MethodNode)})},
  1148. args: ["aMethodScope"],
  1149. source: "scope: aMethodScope\x0a\x09scope := aMethodScope",
  1150. messageSends: [],
  1151. referencedClasses: []
  1152. }),
  1153. smalltalk.MethodNode);
  1154. smalltalk.addMethod(
  1155. smalltalk.method({
  1156. selector: "selector",
  1157. category: 'accessing',
  1158. fn: function (){
  1159. var self=this;
  1160. return smalltalk.withContext(function($ctx1) {
  1161. var $1;
  1162. $1=self["@selector"];
  1163. return $1;
  1164. }, function($ctx1) {$ctx1.fill(self,"selector",{},smalltalk.MethodNode)})},
  1165. args: [],
  1166. source: "selector\x0a\x09^selector",
  1167. messageSends: [],
  1168. referencedClasses: []
  1169. }),
  1170. smalltalk.MethodNode);
  1171. smalltalk.addMethod(
  1172. smalltalk.method({
  1173. selector: "selector:",
  1174. category: 'accessing',
  1175. fn: function (aString){
  1176. var self=this;
  1177. return smalltalk.withContext(function($ctx1) {
  1178. self["@selector"]=aString;
  1179. return self}, function($ctx1) {$ctx1.fill(self,"selector:",{aString:aString},smalltalk.MethodNode)})},
  1180. args: ["aString"],
  1181. source: "selector: aString\x0a\x09selector := aString",
  1182. messageSends: [],
  1183. referencedClasses: []
  1184. }),
  1185. smalltalk.MethodNode);
  1186. smalltalk.addMethod(
  1187. smalltalk.method({
  1188. selector: "source",
  1189. category: 'accessing',
  1190. fn: function (){
  1191. var self=this;
  1192. return smalltalk.withContext(function($ctx1) {
  1193. var $1;
  1194. $1=self["@source"];
  1195. return $1;
  1196. }, function($ctx1) {$ctx1.fill(self,"source",{},smalltalk.MethodNode)})},
  1197. args: [],
  1198. source: "source\x0a\x09^source",
  1199. messageSends: [],
  1200. referencedClasses: []
  1201. }),
  1202. smalltalk.MethodNode);
  1203. smalltalk.addMethod(
  1204. smalltalk.method({
  1205. selector: "source:",
  1206. category: 'accessing',
  1207. fn: function (aString){
  1208. var self=this;
  1209. return smalltalk.withContext(function($ctx1) {
  1210. self["@source"]=aString;
  1211. return self}, function($ctx1) {$ctx1.fill(self,"source:",{aString:aString},smalltalk.MethodNode)})},
  1212. args: ["aString"],
  1213. source: "source: aString\x0a\x09source := aString",
  1214. messageSends: [],
  1215. referencedClasses: []
  1216. }),
  1217. smalltalk.MethodNode);
  1218. smalltalk.addMethod(
  1219. smalltalk.method({
  1220. selector: "superSends",
  1221. category: 'accessing',
  1222. fn: function (){
  1223. var self=this;
  1224. return smalltalk.withContext(function($ctx1) {
  1225. var $1;
  1226. $1=self["@superSends"];
  1227. return $1;
  1228. }, function($ctx1) {$ctx1.fill(self,"superSends",{},smalltalk.MethodNode)})},
  1229. args: [],
  1230. source: "superSends\x0a\x09^ superSends",
  1231. messageSends: [],
  1232. referencedClasses: []
  1233. }),
  1234. smalltalk.MethodNode);
  1235. smalltalk.addMethod(
  1236. smalltalk.method({
  1237. selector: "superSends:",
  1238. category: 'accessing',
  1239. fn: function (aCollection){
  1240. var self=this;
  1241. return smalltalk.withContext(function($ctx1) {
  1242. self["@superSends"]=aCollection;
  1243. return self}, function($ctx1) {$ctx1.fill(self,"superSends:",{aCollection:aCollection},smalltalk.MethodNode)})},
  1244. args: ["aCollection"],
  1245. source: "superSends: aCollection\x0a\x09superSends := aCollection",
  1246. messageSends: [],
  1247. referencedClasses: []
  1248. }),
  1249. smalltalk.MethodNode);
  1250. smalltalk.addClass('ReturnNode', smalltalk.Node, ['scope'], 'Compiler-AST');
  1251. smalltalk.ReturnNode.comment="I represent an return node. At the AST level, there is not difference between a local return or non-local return.";
  1252. smalltalk.addMethod(
  1253. smalltalk.method({
  1254. selector: "accept:",
  1255. category: 'visiting',
  1256. fn: function (aVisitor){
  1257. var self=this;
  1258. return smalltalk.withContext(function($ctx1) {
  1259. var $1;
  1260. $1=_st(aVisitor)._visitReturnNode_(self);
  1261. return $1;
  1262. }, function($ctx1) {$ctx1.fill(self,"accept:",{aVisitor:aVisitor},smalltalk.ReturnNode)})},
  1263. args: ["aVisitor"],
  1264. source: "accept: aVisitor\x0a\x09^ aVisitor visitReturnNode: self",
  1265. messageSends: ["visitReturnNode:"],
  1266. referencedClasses: []
  1267. }),
  1268. smalltalk.ReturnNode);
  1269. smalltalk.addMethod(
  1270. smalltalk.method({
  1271. selector: "isReturnNode",
  1272. category: 'testing',
  1273. fn: function (){
  1274. var self=this;
  1275. return smalltalk.withContext(function($ctx1) {
  1276. return true;
  1277. }, function($ctx1) {$ctx1.fill(self,"isReturnNode",{},smalltalk.ReturnNode)})},
  1278. args: [],
  1279. source: "isReturnNode\x0a\x09^ true",
  1280. messageSends: [],
  1281. referencedClasses: []
  1282. }),
  1283. smalltalk.ReturnNode);
  1284. smalltalk.addMethod(
  1285. smalltalk.method({
  1286. selector: "nonLocalReturn",
  1287. category: 'testing',
  1288. fn: function (){
  1289. var self=this;
  1290. return smalltalk.withContext(function($ctx1) {
  1291. var $1;
  1292. $1=_st(_st(self._scope())._isMethodScope())._not();
  1293. return $1;
  1294. }, function($ctx1) {$ctx1.fill(self,"nonLocalReturn",{},smalltalk.ReturnNode)})},
  1295. args: [],
  1296. source: "nonLocalReturn\x0a\x09^ self scope isMethodScope not",
  1297. messageSends: ["not", "isMethodScope", "scope"],
  1298. referencedClasses: []
  1299. }),
  1300. smalltalk.ReturnNode);
  1301. smalltalk.addMethod(
  1302. smalltalk.method({
  1303. selector: "scope",
  1304. category: 'accessing',
  1305. fn: function (){
  1306. var self=this;
  1307. return smalltalk.withContext(function($ctx1) {
  1308. var $1;
  1309. $1=self["@scope"];
  1310. return $1;
  1311. }, function($ctx1) {$ctx1.fill(self,"scope",{},smalltalk.ReturnNode)})},
  1312. args: [],
  1313. source: "scope\x0a\x09^ scope",
  1314. messageSends: [],
  1315. referencedClasses: []
  1316. }),
  1317. smalltalk.ReturnNode);
  1318. smalltalk.addMethod(
  1319. smalltalk.method({
  1320. selector: "scope:",
  1321. category: 'accessing',
  1322. fn: function (aLexicalScope){
  1323. var self=this;
  1324. return smalltalk.withContext(function($ctx1) {
  1325. self["@scope"]=aLexicalScope;
  1326. return self}, function($ctx1) {$ctx1.fill(self,"scope:",{aLexicalScope:aLexicalScope},smalltalk.ReturnNode)})},
  1327. args: ["aLexicalScope"],
  1328. source: "scope: aLexicalScope\x0a\x09scope := aLexicalScope",
  1329. messageSends: [],
  1330. referencedClasses: []
  1331. }),
  1332. smalltalk.ReturnNode);
  1333. smalltalk.addClass('SendNode', smalltalk.Node, ['selector', 'arguments', 'receiver', 'superSend', 'index'], 'Compiler-AST');
  1334. smalltalk.SendNode.comment="I represent an message send node.";
  1335. smalltalk.addMethod(
  1336. smalltalk.method({
  1337. selector: "accept:",
  1338. category: 'visiting',
  1339. fn: function (aVisitor){
  1340. var self=this;
  1341. return smalltalk.withContext(function($ctx1) {
  1342. var $1;
  1343. $1=_st(aVisitor)._visitSendNode_(self);
  1344. return $1;
  1345. }, function($ctx1) {$ctx1.fill(self,"accept:",{aVisitor:aVisitor},smalltalk.SendNode)})},
  1346. args: ["aVisitor"],
  1347. source: "accept: aVisitor\x0a\x09^ aVisitor visitSendNode: self",
  1348. messageSends: ["visitSendNode:"],
  1349. referencedClasses: []
  1350. }),
  1351. smalltalk.SendNode);
  1352. smalltalk.addMethod(
  1353. smalltalk.method({
  1354. selector: "arguments",
  1355. category: 'accessing',
  1356. fn: function (){
  1357. var self=this;
  1358. return smalltalk.withContext(function($ctx1) {
  1359. var $2,$1;
  1360. $2=self["@arguments"];
  1361. if(($receiver = $2) == nil || $receiver == undefined){
  1362. self["@arguments"]=[];
  1363. $1=self["@arguments"];
  1364. } else {
  1365. $1=$2;
  1366. };
  1367. return $1;
  1368. }, function($ctx1) {$ctx1.fill(self,"arguments",{},smalltalk.SendNode)})},
  1369. args: [],
  1370. source: "arguments\x0a\x09^arguments ifNil: [arguments := #()]",
  1371. messageSends: ["ifNil:"],
  1372. referencedClasses: []
  1373. }),
  1374. smalltalk.SendNode);
  1375. smalltalk.addMethod(
  1376. smalltalk.method({
  1377. selector: "arguments:",
  1378. category: 'accessing',
  1379. fn: function (aCollection){
  1380. var self=this;
  1381. return smalltalk.withContext(function($ctx1) {
  1382. self["@arguments"]=aCollection;
  1383. _st(aCollection)._do_((function(each){
  1384. return smalltalk.withContext(function($ctx2) {
  1385. return _st(each)._parent_(self);
  1386. }, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1,1)})}));
  1387. return self}, function($ctx1) {$ctx1.fill(self,"arguments:",{aCollection:aCollection},smalltalk.SendNode)})},
  1388. args: ["aCollection"],
  1389. source: "arguments: aCollection\x0a\x09arguments := aCollection.\x0a\x09aCollection do: [ :each | each parent: self ]",
  1390. messageSends: ["do:", "parent:"],
  1391. referencedClasses: []
  1392. }),
  1393. smalltalk.SendNode);
  1394. smalltalk.addMethod(
  1395. smalltalk.method({
  1396. selector: "cascadeNodeWithMessages:",
  1397. category: 'accessing',
  1398. fn: function (aCollection){
  1399. var self=this;
  1400. var first;
  1401. function $SendNode(){return smalltalk.SendNode||(typeof SendNode=="undefined"?nil:SendNode)}
  1402. function $CascadeNode(){return smalltalk.CascadeNode||(typeof CascadeNode=="undefined"?nil:CascadeNode)}
  1403. function $Array(){return smalltalk.Array||(typeof Array=="undefined"?nil:Array)}
  1404. return smalltalk.withContext(function($ctx1) {
  1405. var $1,$2,$4,$5,$3;
  1406. $1=_st($SendNode())._new();
  1407. _st($1)._selector_(self._selector());
  1408. _st($1)._arguments_(self._arguments());
  1409. $2=_st($1)._yourself();
  1410. first=$2;
  1411. $4=_st($CascadeNode())._new();
  1412. _st($4)._receiver_(self._receiver());
  1413. _st($4)._nodes_(_st(_st($Array())._with_(first)).__comma(aCollection));
  1414. $5=_st($4)._yourself();
  1415. $3=$5;
  1416. return $3;
  1417. }, function($ctx1) {$ctx1.fill(self,"cascadeNodeWithMessages:",{aCollection:aCollection,first:first},smalltalk.SendNode)})},
  1418. args: ["aCollection"],
  1419. source: "cascadeNodeWithMessages: aCollection\x0a\x09| first |\x0a\x09first := SendNode new\x0a\x09\x09selector: self selector;\x0a\x09\x09arguments: self arguments;\x0a\x09\x09yourself.\x0a\x09^CascadeNode new\x0a\x09\x09receiver: self receiver;\x0a\x09\x09nodes: (Array with: first), aCollection;\x0a\x09\x09yourself",
  1420. messageSends: ["selector:", "new", "selector", "arguments:", "arguments", "yourself", "receiver:", "receiver", "nodes:", ",", "with:"],
  1421. referencedClasses: ["SendNode", "CascadeNode", "Array"]
  1422. }),
  1423. smalltalk.SendNode);
  1424. smalltalk.addMethod(
  1425. smalltalk.method({
  1426. selector: "index",
  1427. category: 'accessing',
  1428. fn: function (){
  1429. var self=this;
  1430. return smalltalk.withContext(function($ctx1) {
  1431. var $1;
  1432. $1=self["@index"];
  1433. return $1;
  1434. }, function($ctx1) {$ctx1.fill(self,"index",{},smalltalk.SendNode)})},
  1435. args: [],
  1436. source: "index\x0a\x09^ index",
  1437. messageSends: [],
  1438. referencedClasses: []
  1439. }),
  1440. smalltalk.SendNode);
  1441. smalltalk.addMethod(
  1442. smalltalk.method({
  1443. selector: "index:",
  1444. category: 'accessing',
  1445. fn: function (anInteger){
  1446. var self=this;
  1447. return smalltalk.withContext(function($ctx1) {
  1448. self["@index"]=anInteger;
  1449. return self}, function($ctx1) {$ctx1.fill(self,"index:",{anInteger:anInteger},smalltalk.SendNode)})},
  1450. args: ["anInteger"],
  1451. source: "index: anInteger\x0a\x09index := anInteger",
  1452. messageSends: [],
  1453. referencedClasses: []
  1454. }),
  1455. smalltalk.SendNode);
  1456. smalltalk.addMethod(
  1457. smalltalk.method({
  1458. selector: "isCascadeSendNode",
  1459. category: 'testing',
  1460. fn: function (){
  1461. var self=this;
  1462. return smalltalk.withContext(function($ctx1) {
  1463. var $1;
  1464. $1=_st(self._parent())._isCascadeNode();
  1465. return $1;
  1466. }, function($ctx1) {$ctx1.fill(self,"isCascadeSendNode",{},smalltalk.SendNode)})},
  1467. args: [],
  1468. source: "isCascadeSendNode\x0a\x09^ self parent isCascadeNode",
  1469. messageSends: ["isCascadeNode", "parent"],
  1470. referencedClasses: []
  1471. }),
  1472. smalltalk.SendNode);
  1473. smalltalk.addMethod(
  1474. smalltalk.method({
  1475. selector: "isSendNode",
  1476. category: 'testing',
  1477. fn: function (){
  1478. var self=this;
  1479. return smalltalk.withContext(function($ctx1) {
  1480. return true;
  1481. }, function($ctx1) {$ctx1.fill(self,"isSendNode",{},smalltalk.SendNode)})},
  1482. args: [],
  1483. source: "isSendNode\x0a\x09^ true",
  1484. messageSends: [],
  1485. referencedClasses: []
  1486. }),
  1487. smalltalk.SendNode);
  1488. smalltalk.addMethod(
  1489. smalltalk.method({
  1490. selector: "nodes",
  1491. category: 'accessing',
  1492. fn: function (){
  1493. var self=this;
  1494. function $Array(){return smalltalk.Array||(typeof Array=="undefined"?nil:Array)}
  1495. return smalltalk.withContext(function($ctx1) {
  1496. var $1,$2,$4,$5,$3;
  1497. $1=self._receiver();
  1498. if(($receiver = $1) == nil || $receiver == undefined){
  1499. $2=_st(self._arguments())._copy();
  1500. return $2;
  1501. } else {
  1502. $1;
  1503. };
  1504. $4=_st($Array())._with_(self._receiver());
  1505. _st($4)._addAll_(self._arguments());
  1506. $5=_st($4)._yourself();
  1507. $3=$5;
  1508. return $3;
  1509. }, function($ctx1) {$ctx1.fill(self,"nodes",{},smalltalk.SendNode)})},
  1510. args: [],
  1511. source: "nodes\x0a\x09self receiver ifNil: [ ^ self arguments copy ].\x0a\x09\x0a\x09^ (Array with: self receiver)\x0a\x09\x09addAll: self arguments;\x0a\x09\x09yourself",
  1512. messageSends: ["ifNil:", "receiver", "copy", "arguments", "addAll:", "with:", "yourself"],
  1513. referencedClasses: ["Array"]
  1514. }),
  1515. smalltalk.SendNode);
  1516. smalltalk.addMethod(
  1517. smalltalk.method({
  1518. selector: "receiver",
  1519. category: 'accessing',
  1520. fn: function (){
  1521. var self=this;
  1522. return smalltalk.withContext(function($ctx1) {
  1523. var $1;
  1524. $1=self["@receiver"];
  1525. return $1;
  1526. }, function($ctx1) {$ctx1.fill(self,"receiver",{},smalltalk.SendNode)})},
  1527. args: [],
  1528. source: "receiver\x0a\x09^receiver",
  1529. messageSends: [],
  1530. referencedClasses: []
  1531. }),
  1532. smalltalk.SendNode);
  1533. smalltalk.addMethod(
  1534. smalltalk.method({
  1535. selector: "receiver:",
  1536. category: 'accessing',
  1537. fn: function (aNode){
  1538. var self=this;
  1539. return smalltalk.withContext(function($ctx1) {
  1540. var $1;
  1541. self["@receiver"]=aNode;
  1542. $1=_st(aNode)._isNode();
  1543. if(smalltalk.assert($1)){
  1544. _st(aNode)._parent_(self);
  1545. };
  1546. return self}, function($ctx1) {$ctx1.fill(self,"receiver:",{aNode:aNode},smalltalk.SendNode)})},
  1547. args: ["aNode"],
  1548. source: "receiver: aNode\x0a\x09receiver := aNode.\x0a\x09aNode isNode ifTrue: [\x0a\x09\x09aNode parent: self ]",
  1549. messageSends: ["ifTrue:", "isNode", "parent:"],
  1550. referencedClasses: []
  1551. }),
  1552. smalltalk.SendNode);
  1553. smalltalk.addMethod(
  1554. smalltalk.method({
  1555. selector: "selector",
  1556. category: 'accessing',
  1557. fn: function (){
  1558. var self=this;
  1559. return smalltalk.withContext(function($ctx1) {
  1560. var $1;
  1561. $1=self["@selector"];
  1562. return $1;
  1563. }, function($ctx1) {$ctx1.fill(self,"selector",{},smalltalk.SendNode)})},
  1564. args: [],
  1565. source: "selector\x0a\x09^selector",
  1566. messageSends: [],
  1567. referencedClasses: []
  1568. }),
  1569. smalltalk.SendNode);
  1570. smalltalk.addMethod(
  1571. smalltalk.method({
  1572. selector: "selector:",
  1573. category: 'accessing',
  1574. fn: function (aString){
  1575. var self=this;
  1576. return smalltalk.withContext(function($ctx1) {
  1577. self["@selector"]=aString;
  1578. return self}, function($ctx1) {$ctx1.fill(self,"selector:",{aString:aString},smalltalk.SendNode)})},
  1579. args: ["aString"],
  1580. source: "selector: aString\x0a\x09selector := aString",
  1581. messageSends: [],
  1582. referencedClasses: []
  1583. }),
  1584. smalltalk.SendNode);
  1585. smalltalk.addMethod(
  1586. smalltalk.method({
  1587. selector: "stopOnStepping",
  1588. category: 'testing',
  1589. fn: function (){
  1590. var self=this;
  1591. return smalltalk.withContext(function($ctx1) {
  1592. return true;
  1593. }, function($ctx1) {$ctx1.fill(self,"stopOnStepping",{},smalltalk.SendNode)})},
  1594. args: [],
  1595. source: "stopOnStepping\x0a\x09^ true",
  1596. messageSends: [],
  1597. referencedClasses: []
  1598. }),
  1599. smalltalk.SendNode);
  1600. smalltalk.addMethod(
  1601. smalltalk.method({
  1602. selector: "superSend",
  1603. category: 'accessing',
  1604. fn: function (){
  1605. var self=this;
  1606. return smalltalk.withContext(function($ctx1) {
  1607. var $2,$1;
  1608. $2=self["@superSend"];
  1609. if(($receiver = $2) == nil || $receiver == undefined){
  1610. $1=false;
  1611. } else {
  1612. $1=$2;
  1613. };
  1614. return $1;
  1615. }, function($ctx1) {$ctx1.fill(self,"superSend",{},smalltalk.SendNode)})},
  1616. args: [],
  1617. source: "superSend\x0a\x09^ superSend ifNil: [ false ]",
  1618. messageSends: ["ifNil:"],
  1619. referencedClasses: []
  1620. }),
  1621. smalltalk.SendNode);
  1622. smalltalk.addMethod(
  1623. smalltalk.method({
  1624. selector: "superSend:",
  1625. category: 'accessing',
  1626. fn: function (aBoolean){
  1627. var self=this;
  1628. return smalltalk.withContext(function($ctx1) {
  1629. self["@superSend"]=aBoolean;
  1630. return self}, function($ctx1) {$ctx1.fill(self,"superSend:",{aBoolean:aBoolean},smalltalk.SendNode)})},
  1631. args: ["aBoolean"],
  1632. source: "superSend: aBoolean\x0a\x09superSend := aBoolean",
  1633. messageSends: [],
  1634. referencedClasses: []
  1635. }),
  1636. smalltalk.SendNode);
  1637. smalltalk.addMethod(
  1638. smalltalk.method({
  1639. selector: "valueForReceiver:",
  1640. category: 'accessing',
  1641. fn: function (anObject){
  1642. var self=this;
  1643. function $SendNode(){return smalltalk.SendNode||(typeof SendNode=="undefined"?nil:SendNode)}
  1644. return smalltalk.withContext(function($ctx1) {
  1645. var $2,$3,$5,$4,$6,$1;
  1646. $2=_st($SendNode())._new();
  1647. _st($2)._position_(self._position());
  1648. $3=$2;
  1649. $5=self._receiver();
  1650. if(($receiver = $5) == nil || $receiver == undefined){
  1651. $4=anObject;
  1652. } else {
  1653. $4=_st(self._receiver())._valueForReceiver_(anObject);
  1654. };
  1655. _st($3)._receiver_($4);
  1656. _st($2)._selector_(self._selector());
  1657. _st($2)._arguments_(self._arguments());
  1658. $6=_st($2)._yourself();
  1659. $1=$6;
  1660. return $1;
  1661. }, function($ctx1) {$ctx1.fill(self,"valueForReceiver:",{anObject:anObject},smalltalk.SendNode)})},
  1662. args: ["anObject"],
  1663. source: "valueForReceiver: anObject\x0a\x09^SendNode new\x0a\x09\x09position: self position;\x0a\x09\x09receiver: (self receiver\x0a\x09\x09ifNil: [anObject]\x0a\x09\x09ifNotNil: [self receiver valueForReceiver: anObject]);\x0a\x09\x09selector: self selector;\x0a\x09\x09arguments: self arguments;\x0a\x09\x09yourself",
  1664. messageSends: ["position:", "new", "position", "receiver:", "ifNil:ifNotNil:", "receiver", "valueForReceiver:", "selector:", "selector", "arguments:", "arguments", "yourself"],
  1665. referencedClasses: ["SendNode"]
  1666. }),
  1667. smalltalk.SendNode);
  1668. smalltalk.addClass('SequenceNode', smalltalk.Node, ['temps', 'scope'], 'Compiler-AST');
  1669. smalltalk.SequenceNode.comment="I represent an sequence node. A sequence represent a set of instructions inside the same scope (the method scope or a block scope).";
  1670. smalltalk.addMethod(
  1671. smalltalk.method({
  1672. selector: "accept:",
  1673. category: 'visiting',
  1674. fn: function (aVisitor){
  1675. var self=this;
  1676. return smalltalk.withContext(function($ctx1) {
  1677. var $1;
  1678. $1=_st(aVisitor)._visitSequenceNode_(self);
  1679. return $1;
  1680. }, function($ctx1) {$ctx1.fill(self,"accept:",{aVisitor:aVisitor},smalltalk.SequenceNode)})},
  1681. args: ["aVisitor"],
  1682. source: "accept: aVisitor\x0a\x09^ aVisitor visitSequenceNode: self",
  1683. messageSends: ["visitSequenceNode:"],
  1684. referencedClasses: []
  1685. }),
  1686. smalltalk.SequenceNode);
  1687. smalltalk.addMethod(
  1688. smalltalk.method({
  1689. selector: "asBlockSequenceNode",
  1690. category: 'testing',
  1691. fn: function (){
  1692. var self=this;
  1693. function $BlockSequenceNode(){return smalltalk.BlockSequenceNode||(typeof BlockSequenceNode=="undefined"?nil:BlockSequenceNode)}
  1694. return smalltalk.withContext(function($ctx1) {
  1695. var $2,$3,$1;
  1696. $2=_st($BlockSequenceNode())._new();
  1697. _st($2)._position_(self._position());
  1698. _st($2)._nodes_(self._nodes());
  1699. _st($2)._temps_(self._temps());
  1700. $3=_st($2)._yourself();
  1701. $1=$3;
  1702. return $1;
  1703. }, function($ctx1) {$ctx1.fill(self,"asBlockSequenceNode",{},smalltalk.SequenceNode)})},
  1704. args: [],
  1705. source: "asBlockSequenceNode\x0a\x09^BlockSequenceNode new\x0a\x09\x09position: self position;\x0a\x09\x09nodes: self nodes;\x0a\x09\x09temps: self temps;\x0a\x09\x09yourself",
  1706. messageSends: ["position:", "new", "position", "nodes:", "nodes", "temps:", "temps", "yourself"],
  1707. referencedClasses: ["BlockSequenceNode"]
  1708. }),
  1709. smalltalk.SequenceNode);
  1710. smalltalk.addMethod(
  1711. smalltalk.method({
  1712. selector: "scope",
  1713. category: 'accessing',
  1714. fn: function (){
  1715. var self=this;
  1716. return smalltalk.withContext(function($ctx1) {
  1717. var $1;
  1718. $1=self["@scope"];
  1719. return $1;
  1720. }, function($ctx1) {$ctx1.fill(self,"scope",{},smalltalk.SequenceNode)})},
  1721. args: [],
  1722. source: "scope\x0a\x09^ scope",
  1723. messageSends: [],
  1724. referencedClasses: []
  1725. }),
  1726. smalltalk.SequenceNode);
  1727. smalltalk.addMethod(
  1728. smalltalk.method({
  1729. selector: "scope:",
  1730. category: 'accessing',
  1731. fn: function (aLexicalScope){
  1732. var self=this;
  1733. return smalltalk.withContext(function($ctx1) {
  1734. self["@scope"]=aLexicalScope;
  1735. return self}, function($ctx1) {$ctx1.fill(self,"scope:",{aLexicalScope:aLexicalScope},smalltalk.SequenceNode)})},
  1736. args: ["aLexicalScope"],
  1737. source: "scope: aLexicalScope\x0a\x09scope := aLexicalScope",
  1738. messageSends: [],
  1739. referencedClasses: []
  1740. }),
  1741. smalltalk.SequenceNode);
  1742. smalltalk.addMethod(
  1743. smalltalk.method({
  1744. selector: "temps",
  1745. category: 'accessing',
  1746. fn: function (){
  1747. var self=this;
  1748. return smalltalk.withContext(function($ctx1) {
  1749. var $2,$1;
  1750. $2=self["@temps"];
  1751. if(($receiver = $2) == nil || $receiver == undefined){
  1752. $1=[];
  1753. } else {
  1754. $1=$2;
  1755. };
  1756. return $1;
  1757. }, function($ctx1) {$ctx1.fill(self,"temps",{},smalltalk.SequenceNode)})},
  1758. args: [],
  1759. source: "temps\x0a\x09^temps ifNil: [#()]",
  1760. messageSends: ["ifNil:"],
  1761. referencedClasses: []
  1762. }),
  1763. smalltalk.SequenceNode);
  1764. smalltalk.addMethod(
  1765. smalltalk.method({
  1766. selector: "temps:",
  1767. category: 'accessing',
  1768. fn: function (aCollection){
  1769. var self=this;
  1770. return smalltalk.withContext(function($ctx1) {
  1771. self["@temps"]=aCollection;
  1772. return self}, function($ctx1) {$ctx1.fill(self,"temps:",{aCollection:aCollection},smalltalk.SequenceNode)})},
  1773. args: ["aCollection"],
  1774. source: "temps: aCollection\x0a\x09temps := aCollection",
  1775. messageSends: [],
  1776. referencedClasses: []
  1777. }),
  1778. smalltalk.SequenceNode);
  1779. smalltalk.addClass('BlockSequenceNode', smalltalk.SequenceNode, [], 'Compiler-AST');
  1780. smalltalk.BlockSequenceNode.comment="I represent an special sequence node for block scopes.";
  1781. smalltalk.addMethod(
  1782. smalltalk.method({
  1783. selector: "accept:",
  1784. category: 'visiting',
  1785. fn: function (aVisitor){
  1786. var self=this;
  1787. return smalltalk.withContext(function($ctx1) {
  1788. var $1;
  1789. $1=_st(aVisitor)._visitBlockSequenceNode_(self);
  1790. return $1;
  1791. }, function($ctx1) {$ctx1.fill(self,"accept:",{aVisitor:aVisitor},smalltalk.BlockSequenceNode)})},
  1792. args: ["aVisitor"],
  1793. source: "accept: aVisitor\x0a\x09^ aVisitor visitBlockSequenceNode: self",
  1794. messageSends: ["visitBlockSequenceNode:"],
  1795. referencedClasses: []
  1796. }),
  1797. smalltalk.BlockSequenceNode);
  1798. smalltalk.addMethod(
  1799. smalltalk.method({
  1800. selector: "isBlockSequenceNode",
  1801. category: 'testing',
  1802. fn: function (){
  1803. var self=this;
  1804. return smalltalk.withContext(function($ctx1) {
  1805. return true;
  1806. }, function($ctx1) {$ctx1.fill(self,"isBlockSequenceNode",{},smalltalk.BlockSequenceNode)})},
  1807. args: [],
  1808. source: "isBlockSequenceNode\x0a\x09^true",
  1809. messageSends: [],
  1810. referencedClasses: []
  1811. }),
  1812. smalltalk.BlockSequenceNode);
  1813. smalltalk.addClass('ValueNode', smalltalk.Node, ['value'], 'Compiler-AST');
  1814. smalltalk.ValueNode.comment="I represent a value node.";
  1815. smalltalk.addMethod(
  1816. smalltalk.method({
  1817. selector: "accept:",
  1818. category: 'visiting',
  1819. fn: function (aVisitor){
  1820. var self=this;
  1821. return smalltalk.withContext(function($ctx1) {
  1822. var $1;
  1823. $1=_st(aVisitor)._visitValueNode_(self);
  1824. return $1;
  1825. }, function($ctx1) {$ctx1.fill(self,"accept:",{aVisitor:aVisitor},smalltalk.ValueNode)})},
  1826. args: ["aVisitor"],
  1827. source: "accept: aVisitor\x0a\x09^ aVisitor visitValueNode: self",
  1828. messageSends: ["visitValueNode:"],
  1829. referencedClasses: []
  1830. }),
  1831. smalltalk.ValueNode);
  1832. smalltalk.addMethod(
  1833. smalltalk.method({
  1834. selector: "isImmutable",
  1835. category: 'testing',
  1836. fn: function (){
  1837. var self=this;
  1838. return smalltalk.withContext(function($ctx1) {
  1839. var $1;
  1840. $1=_st(self._value())._isImmutable();
  1841. return $1;
  1842. }, function($ctx1) {$ctx1.fill(self,"isImmutable",{},smalltalk.ValueNode)})},
  1843. args: [],
  1844. source: "isImmutable\x0a\x09^ self value isImmutable",
  1845. messageSends: ["isImmutable", "value"],
  1846. referencedClasses: []
  1847. }),
  1848. smalltalk.ValueNode);
  1849. smalltalk.addMethod(
  1850. smalltalk.method({
  1851. selector: "isValueNode",
  1852. category: 'testing',
  1853. fn: function (){
  1854. var self=this;
  1855. return smalltalk.withContext(function($ctx1) {
  1856. return true;
  1857. }, function($ctx1) {$ctx1.fill(self,"isValueNode",{},smalltalk.ValueNode)})},
  1858. args: [],
  1859. source: "isValueNode\x0a\x09^true",
  1860. messageSends: [],
  1861. referencedClasses: []
  1862. }),
  1863. smalltalk.ValueNode);
  1864. smalltalk.addMethod(
  1865. smalltalk.method({
  1866. selector: "value",
  1867. category: 'accessing',
  1868. fn: function (){
  1869. var self=this;
  1870. return smalltalk.withContext(function($ctx1) {
  1871. var $1;
  1872. $1=self["@value"];
  1873. return $1;
  1874. }, function($ctx1) {$ctx1.fill(self,"value",{},smalltalk.ValueNode)})},
  1875. args: [],
  1876. source: "value\x0a\x09^value",
  1877. messageSends: [],
  1878. referencedClasses: []
  1879. }),
  1880. smalltalk.ValueNode);
  1881. smalltalk.addMethod(
  1882. smalltalk.method({
  1883. selector: "value:",
  1884. category: 'accessing',
  1885. fn: function (anObject){
  1886. var self=this;
  1887. return smalltalk.withContext(function($ctx1) {
  1888. self["@value"]=anObject;
  1889. return self}, function($ctx1) {$ctx1.fill(self,"value:",{anObject:anObject},smalltalk.ValueNode)})},
  1890. args: ["anObject"],
  1891. source: "value: anObject\x0a\x09value := anObject",
  1892. messageSends: [],
  1893. referencedClasses: []
  1894. }),
  1895. smalltalk.ValueNode);
  1896. smalltalk.addMethod(
  1897. smalltalk.method({
  1898. selector: "xxxDoIt",
  1899. category: 'xxxDoIt',
  1900. fn: function (){
  1901. var self=this;
  1902. return smalltalk.withContext(function($ctx1) {
  1903. var $1;
  1904. $1=_st((function(){
  1905. return smalltalk.withContext(function($ctx2) {
  1906. return self._stack();
  1907. }, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}))._value();
  1908. return $1;
  1909. }, function($ctx1) {$ctx1.fill(self,"xxxDoIt",{},smalltalk.ValueNode)})},
  1910. args: [],
  1911. source: "xxxDoIt ^[self stack] value",
  1912. messageSends: ["value", "stack"],
  1913. referencedClasses: []
  1914. }),
  1915. smalltalk.ValueNode);
  1916. smalltalk.addClass('VariableNode', smalltalk.ValueNode, ['assigned', 'binding'], 'Compiler-AST');
  1917. smalltalk.VariableNode.comment="I represent an variable node.";
  1918. smalltalk.addMethod(
  1919. smalltalk.method({
  1920. selector: "accept:",
  1921. category: 'visiting',
  1922. fn: function (aVisitor){
  1923. var self=this;
  1924. return smalltalk.withContext(function($ctx1) {
  1925. var $1;
  1926. $1=_st(aVisitor)._visitVariableNode_(self);
  1927. return $1;
  1928. }, function($ctx1) {$ctx1.fill(self,"accept:",{aVisitor:aVisitor},smalltalk.VariableNode)})},
  1929. args: ["aVisitor"],
  1930. source: "accept: aVisitor\x0a\x09^ aVisitor visitVariableNode: self",
  1931. messageSends: ["visitVariableNode:"],
  1932. referencedClasses: []
  1933. }),
  1934. smalltalk.VariableNode);
  1935. smalltalk.addMethod(
  1936. smalltalk.method({
  1937. selector: "alias",
  1938. category: 'accessing',
  1939. fn: function (){
  1940. var self=this;
  1941. return smalltalk.withContext(function($ctx1) {
  1942. var $1;
  1943. $1=_st(self._binding())._alias();
  1944. return $1;
  1945. }, function($ctx1) {$ctx1.fill(self,"alias",{},smalltalk.VariableNode)})},
  1946. args: [],
  1947. source: "alias\x0a\x09^ self binding alias",
  1948. messageSends: ["alias", "binding"],
  1949. referencedClasses: []
  1950. }),
  1951. smalltalk.VariableNode);
  1952. smalltalk.addMethod(
  1953. smalltalk.method({
  1954. selector: "assigned",
  1955. category: 'accessing',
  1956. fn: function (){
  1957. var self=this;
  1958. return smalltalk.withContext(function($ctx1) {
  1959. var $2,$1;
  1960. $2=self["@assigned"];
  1961. if(($receiver = $2) == nil || $receiver == undefined){
  1962. $1=false;
  1963. } else {
  1964. $1=$2;
  1965. };
  1966. return $1;
  1967. }, function($ctx1) {$ctx1.fill(self,"assigned",{},smalltalk.VariableNode)})},
  1968. args: [],
  1969. source: "assigned\x0a\x09^assigned ifNil: [false]",
  1970. messageSends: ["ifNil:"],
  1971. referencedClasses: []
  1972. }),
  1973. smalltalk.VariableNode);
  1974. smalltalk.addMethod(
  1975. smalltalk.method({
  1976. selector: "assigned:",
  1977. category: 'accessing',
  1978. fn: function (aBoolean){
  1979. var self=this;
  1980. return smalltalk.withContext(function($ctx1) {
  1981. self["@assigned"]=aBoolean;
  1982. return self}, function($ctx1) {$ctx1.fill(self,"assigned:",{aBoolean:aBoolean},smalltalk.VariableNode)})},
  1983. args: ["aBoolean"],
  1984. source: "assigned: aBoolean\x0a\x09assigned := aBoolean",
  1985. messageSends: [],
  1986. referencedClasses: []
  1987. }),
  1988. smalltalk.VariableNode);
  1989. smalltalk.addMethod(
  1990. smalltalk.method({
  1991. selector: "beAssigned",
  1992. category: 'accessing',
  1993. fn: function (){
  1994. var self=this;
  1995. return smalltalk.withContext(function($ctx1) {
  1996. _st(self._binding())._validateAssignment();
  1997. self["@assigned"]=true;
  1998. return self}, function($ctx1) {$ctx1.fill(self,"beAssigned",{},smalltalk.VariableNode)})},
  1999. args: [],
  2000. source: "beAssigned\x0a\x09self binding validateAssignment.\x0a\x09assigned := true",
  2001. messageSends: ["validateAssignment", "binding"],
  2002. referencedClasses: []
  2003. }),
  2004. smalltalk.VariableNode);
  2005. smalltalk.addMethod(
  2006. smalltalk.method({
  2007. selector: "binding",
  2008. category: 'accessing',
  2009. fn: function (){
  2010. var self=this;
  2011. return smalltalk.withContext(function($ctx1) {
  2012. var $1;
  2013. $1=self["@binding"];
  2014. return $1;
  2015. }, function($ctx1) {$ctx1.fill(self,"binding",{},smalltalk.VariableNode)})},
  2016. args: [],
  2017. source: "binding\x0a\x09^ binding",
  2018. messageSends: [],
  2019. referencedClasses: []
  2020. }),
  2021. smalltalk.VariableNode);
  2022. smalltalk.addMethod(
  2023. smalltalk.method({
  2024. selector: "binding:",
  2025. category: 'accessing',
  2026. fn: function (aScopeVar){
  2027. var self=this;
  2028. return smalltalk.withContext(function($ctx1) {
  2029. self["@binding"]=aScopeVar;
  2030. return self}, function($ctx1) {$ctx1.fill(self,"binding:",{aScopeVar:aScopeVar},smalltalk.VariableNode)})},
  2031. args: ["aScopeVar"],
  2032. source: "binding: aScopeVar\x0a\x09binding := aScopeVar",
  2033. messageSends: [],
  2034. referencedClasses: []
  2035. }),
  2036. smalltalk.VariableNode);
  2037. smalltalk.addMethod(
  2038. smalltalk.method({
  2039. selector: "isImmutable",
  2040. category: 'testing',
  2041. fn: function (){
  2042. var self=this;
  2043. return smalltalk.withContext(function($ctx1) {
  2044. return false;
  2045. }, function($ctx1) {$ctx1.fill(self,"isImmutable",{},smalltalk.VariableNode)})},
  2046. args: [],
  2047. source: "isImmutable\x0a\x09^false",
  2048. messageSends: [],
  2049. referencedClasses: []
  2050. }),
  2051. smalltalk.VariableNode);
  2052. smalltalk.addClass('ClassReferenceNode', smalltalk.VariableNode, [], 'Compiler-AST');
  2053. smalltalk.ClassReferenceNode.comment="I represent an class reference node.";
  2054. smalltalk.addMethod(
  2055. smalltalk.method({
  2056. selector: "accept:",
  2057. category: 'visiting',
  2058. fn: function (aVisitor){
  2059. var self=this;
  2060. return smalltalk.withContext(function($ctx1) {
  2061. var $1;
  2062. $1=_st(aVisitor)._visitClassReferenceNode_(self);
  2063. return $1;
  2064. }, function($ctx1) {$ctx1.fill(self,"accept:",{aVisitor:aVisitor},smalltalk.ClassReferenceNode)})},
  2065. args: ["aVisitor"],
  2066. source: "accept: aVisitor\x0a\x09^ aVisitor visitClassReferenceNode: self",
  2067. messageSends: ["visitClassReferenceNode:"],
  2068. referencedClasses: []
  2069. }),
  2070. smalltalk.ClassReferenceNode);
  2071. smalltalk.addMethod(
  2072. smalltalk.method({
  2073. selector: "isNode",
  2074. category: '*Compiler-AST',
  2075. fn: function (){
  2076. var self=this;
  2077. return smalltalk.withContext(function($ctx1) {
  2078. return false;
  2079. }, function($ctx1) {$ctx1.fill(self,"isNode",{},smalltalk.Object)})},
  2080. args: [],
  2081. source: "isNode\x0a\x09^ false",
  2082. messageSends: [],
  2083. referencedClasses: []
  2084. }),
  2085. smalltalk.Object);
  2086. smalltalk.addMethod(
  2087. smalltalk.method({
  2088. selector: "ast",
  2089. category: '*Compiler-AST',
  2090. fn: function (){
  2091. var self=this;
  2092. function $Smalltalk(){return smalltalk.Smalltalk||(typeof Smalltalk=="undefined"?nil:Smalltalk)}
  2093. return smalltalk.withContext(function($ctx1) {
  2094. var $1;
  2095. _st(self._source())._ifEmpty_((function(){
  2096. return smalltalk.withContext(function($ctx2) {
  2097. return self._error_("Method source is empty");
  2098. }, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}));
  2099. $1=_st(_st($Smalltalk())._current())._parse_(self._source());
  2100. return $1;
  2101. }, function($ctx1) {$ctx1.fill(self,"ast",{},smalltalk.CompiledMethod)})},
  2102. args: [],
  2103. source: "ast\x0a\x09self source ifEmpty: [ self error: 'Method source is empty' ].\x0a\x09\x0a\x09^ Smalltalk current parse: self source",
  2104. messageSends: ["ifEmpty:", "source", "error:", "parse:", "current"],
  2105. referencedClasses: ["Smalltalk"]
  2106. }),
  2107. smalltalk.CompiledMethod);