resin 0.2.1 → 0.2.2

data/amber/st/Compiler.st

@@ -1,122 +1,175 @@
 Smalltalk current createPackage: 'Compiler' properties: #{}!
-Object subclass: #NodeVisitor
-	instanceVariableNames: ''
-	category: 'Compiler'!
+Object subclass: #ChunkParser
+	instanceVariableNames: 'stream'
+	package: 'Compiler'!
 
-!NodeVisitor methodsFor: 'visiting'!
+!ChunkParser methodsFor: 'accessing'!
 
-visit: aNode
-	aNode accept: self
+stream: aStream
+	stream := aStream
+! !
+
+!ChunkParser methodsFor: 'reading'!
+
+nextChunk
+	"The chunk format (Smalltalk Interchange Format or Fileout format)
+	is a trivial format but can be a bit tricky to understand:
+		- Uses the exclamation mark as delimiter of chunks.
+		- Inside a chunk a normal exclamation mark must be doubled.
+		- A non empty chunk must be a valid Smalltalk expression.
+		- A chunk on top level with a preceding empty chunk is an instruction chunk:
+			- The object created by the expression then takes over reading chunks.
+
+	This metod returns next chunk as a String (trimmed), empty String (all whitespace) or nil."
+
+	| char result chunk |
+	result := '' writeStream.
+        [char := stream next.
+        char notNil] whileTrue: [
+                 char = '!!' ifTrue: [
+                         stream peek = '!!'
+                                ifTrue: [stream next "skipping the escape double"]
+                                ifFalse: [^result contents trimBoth  "chunk end marker found"]].
+                 result nextPut: char].
+	^nil "a chunk needs to end with !!"
+! !
+
+!ChunkParser class methodsFor: 'not yet classified'!
+
+on: aStream
+	^self new stream: aStream
+! !
+
+Object subclass: #Compiler
+	instanceVariableNames: 'currentClass source unknownVariables'
+	package: 'Compiler'!
+
+!Compiler methodsFor: 'accessing'!
+
+codeGeneratorClass
+	^FunCodeGenerator
 !
 
-visitNode: aNode
+currentClass
+	^currentClass
 !
 
-visitMethodNode: aNode
-	self visitNode: aNode
+currentClass: aClass
+	currentClass := aClass
 !
 
-visitSequenceNode: aNode
-	self visitNode: aNode
+source
+	^source ifNil: ['']
 !
 
-visitBlockSequenceNode: aNode
-	self visitSequenceNode: aNode
+source: aString
+	source := aString
 !
 
-visitBlockNode: aNode
-	self visitNode: aNode
+unknownVariables
+	^unknownVariables
 !
 
-visitReturnNode: aNode
-	self visitNode: aNode
+unknownVariables: aCollection
+	unknownVariables := aCollection
+! !
+
+!Compiler methodsFor: 'compiling'!
+
+compile: aString
+	^self compileNode: (self parse: aString)
 !
 
-visitSendNode: aNode
-	self visitNode: aNode
+compile: aString forClass: aClass
+	self currentClass: aClass.
+	self source: aString.
+	^self compile: aString
 !
 
-visitCascadeNode: aNode
-	self visitNode: aNode
+compileExpression: aString
+	self currentClass: DoIt.
+	self source: 'doIt ^[', aString, '] value'.
+	^self compileNode: (self parse: self source)
 !
 
-visitValueNode: aNode
-	self visitNode: aNode
+compileNode: aNode
+	| generator result |
+	generator := self codeGeneratorClass new.
+	generator
+		source: self source;
+		currentClass: self currentClass.
+	result := generator compileNode: aNode.
+	self unknownVariables: generator unknownVariables.
+	^result
 !
 
-visitVariableNode: aNode
+eval: aString
+	<return eval(aString)>
 !
 
-visitAssignmentNode: aNode
-	self visitNode: aNode
+evaluateExpression: aString
+	"Unlike #eval: evaluate a Smalltalk expression and answer the returned object"
+	| result |
+	DoIt addCompiledMethod: (self eval: (self compileExpression: aString)).
+	result := DoIt new doIt.
+	DoIt removeCompiledMethod: (DoIt methodDictionary at: 'doIt').
+	^result
 !
 
-visitClassReferenceNode: aNode
-	self 
-	    nextPutAll: 'smalltalk.';
-	    nextPutAll: aNode value
+install: aString forClass: aBehavior category: anotherString
+	| compiled |
+	compiled := self eval: (self compile: aString forClass: aBehavior).
+	compiled category: anotherString.
+	aBehavior addCompiledMethod: compiled.
+	^compiled
 !
 
-visitJSStatementNode: aNode
-	self 
-	    nextPutAll: 'function(){';
-	    nextPutAll: aNode source;
-	    nextPutAll: '})()'
+parse: aString
+    ^Smalltalk current parse: aString
 !
 
-visitDynamicArrayNode: aNode
-	self visitNode: aNode
+parseExpression: aString
+    ^self parse: 'doIt ^[', aString, '] value'
 !
 
-visitDynamicDictionaryNode: aNode
-	self visitNode: aNode
-! !
+recompile: aClass
+	aClass methodDictionary do: [:each |
+		self install: each source forClass: aClass category: each category].
+	self setupClass: aClass.
+	aClass isMetaclass ifFalse: [self recompile: aClass class]
+!
 
-Object subclass: #DoIt
-	instanceVariableNames: ''
-	category: 'Compiler'!
+recompileAll
+	Smalltalk current classes do: [:each |
+		Transcript show: each; cr.
+		[self recompile: each] valueWithTimeout: 100]
+!
 
-Object subclass: #Importer
-	instanceVariableNames: ''
-	category: 'Compiler'!
+setupClass: aClass
+	<smalltalk.init(aClass)>
+! !
 
-!Importer methodsFor: 'fileIn'!
+!Compiler class methodsFor: 'compiling'!
 
-import: aStream
-    | chunk result parser lastEmpty |
-    parser := ChunkParser on: aStream.
-    lastEmpty := false.
-    [chunk := parser nextChunk.
-     chunk isNil] whileFalse: [
-        chunk isEmpty
-       		ifTrue: [lastEmpty := true]
-       		ifFalse: [
-        		result := Compiler new loadExpression: chunk.
-        		lastEmpty 
-            			ifTrue: [
-                                  	lastEmpty := false.
-                                  	result scanFrom: parser]]]
+recompile: aClass
+	self new recompile: aClass
+!
+
+recompileAll
+	Smalltalk current classes do: [:each |
+		self recompile: each]
 ! !
 
+Object subclass: #DoIt
+	instanceVariableNames: ''
+	package: 'Compiler'!
+
 Object subclass: #Exporter
 	instanceVariableNames: ''
-	category: 'Compiler'!
+	package: 'Compiler'!
 
 !Exporter methodsFor: 'fileOut'!
 
-exportPackage: packageName
-	"Export a given package by name."
-
-	| package |
-	^String streamContents: [:stream |
-                package := Smalltalk current packageAt: packageName.
-                self exportPackageDefinitionOf: package on: stream.
-		"Export classes in dependency order"
-	    	package sortedClasses do: [:each |
-                        stream nextPutAll: (self exportClass: each)].
-		self exportPackageExtensionsOf: package on: stream]
-!
-
 exportAll
     "Export all packages in the system."
 
@@ -133,10 +186,34 @@ exportClass: aClass
 		self exportMethodsOf: aClass on: stream.
 		self exportMetaDefinitionOf: aClass on: stream.
 		self exportMethodsOf: aClass class on: stream]
+!
+
+exportPackage: packageName
+	"Export a given package by name."
+
+	| package |
+	^String streamContents: [:stream |
+                package := Smalltalk current packageAt: packageName.
+                self exportPackageDefinitionOf: package on: stream.
+
+		"Export classes in dependency order.
+		Update (issue #171): Remove duplicates for export"
+	    	package sortedClasses asSet do: [:each |
+                        stream nextPutAll: (self exportClass: each)].
+		self exportPackageExtensionsOf: package on: stream]
 ! !
 
 !Exporter methodsFor: 'private'!
 
+classNameFor: aClass
+	^aClass isMetaclass
+	    ifTrue: [aClass instanceClass name, '.klass']
+	    ifFalse: [
+		aClass isNil
+		    ifTrue: ['nil']
+		    ifFalse: [aClass name]]
+!
+
 exportDefinitionOf: aClass on: aStream
 	aStream 
 	    nextPutAll: 'smalltalk.addClass(';
@@ -156,7 +233,7 @@ exportDefinitionOf: aClass on: aStream
 		nextPutAll: 'smalltalk.';
 		nextPutAll: (self classNameFor: aClass);
 		nextPutAll: '.comment=';
-		nextPutAll: 'unescape(''', aClass comment escaped, ''')'].
+		nextPutAll: aClass comment asJavascript].
 	aStream lf
 !
 
@@ -171,32 +248,16 @@ exportMetaDefinitionOf: aClass on: aStream
 	    aStream nextPutAll: '];', String lf]
 !
 
-exportMethodsOf: aClass on: aStream
-	aClass methodDictionary values do: [:each |
-		(each category match: '^\*') ifFalse: [
-			self exportMethod: each of: aClass on: aStream]].
-	aStream lf
-!
-
-classNameFor: aClass
-	^aClass isMetaclass
-	    ifTrue: [aClass instanceClass name, '.klass']
-	    ifFalse: [
-		aClass isNil
-		    ifTrue: ['nil']
-		    ifFalse: [aClass name]]
-!
-
 exportMethod: aMethod of: aClass on: aStream
 	aStream 
 		nextPutAll: 'smalltalk.addMethod(';lf;
-		nextPutAll: 'unescape(''', aMethod selector asSelector escaped, '''),';lf;
+		nextPutAll: aMethod selector asSelector asJavascript, ',';lf;
 		nextPutAll: 'smalltalk.method({';lf;
-		nextPutAll: 'selector: unescape(''', aMethod selector escaped, '''),';lf;
+		nextPutAll: 'selector: ', aMethod selector asJavascript, ',';lf;
 		nextPutAll: 'category: ''', aMethod category, ''',';lf;
 		nextPutAll: 'fn: ', aMethod fn compiledSource, ',';lf;
 		nextPutAll: 'args: ', aMethod arguments asJavascript, ','; lf;
-		nextPutAll: 'source: unescape(''', aMethod source escaped, '''),';lf;
+		nextPutAll: 'source: ', aMethod source asJavascript, ',';lf;
 		nextPutAll: 'messageSends: ', aMethod messageSends asJavascript, ',';lf;
 		nextPutAll: 'referencedClasses: ', aMethod referencedClasses asJavascript.
 	aStream
@@ -206,13 +267,13 @@ exportMethod: aMethod of: aClass on: aStream
 		nextPutAll: ');';lf;lf
 !
 
-exportPackageExtensionsOf: package on: aStream
-	| name |
-	name := package name.
-	Smalltalk current classes, (Smalltalk current classes collect: [:each | each class]) do: [:each |
-		each methodDictionary values do: [:method |
-			method category = ('*', name) ifTrue: [
-				self exportMethod: method of: each on: aStream]]]
+exportMethodsOf: aClass on: aStream
+	"Issue #143: sort methods alphabetically"
+
+	((aClass methodDictionary values) sorted: [:a :b | a selector <= b selector]) do: [:each |
+		(each category match: '^\*') ifFalse: [
+			self exportMethod: each of: aClass on: aStream]].
+	aStream lf
 !
 
 exportPackageDefinitionOf: package on: aStream
@@ -220,61 +281,202 @@ exportPackageDefinitionOf: package on: aStream
 	    nextPutAll: 'smalltalk.addPackage(';
 	    nextPutAll: '''', package name, ''', ', package propertiesAsJSON , ');'.
 	aStream lf
-! !
-
-Object subclass: #ChunkParser
-	instanceVariableNames: 'stream'
-	category: 'Compiler'!
+!
 
-!ChunkParser methodsFor: 'accessing'!
+exportPackageExtensionsOf: package on: aStream
+	"Issue #143: sort classes and methods alphabetically"
 
-stream: aStream
-	stream := aStream
+	| name |
+	name := package name.
+	(Package sortedClasses: Smalltalk current classes) do: [:each |
+		{each. each class} do: [:aClass | 
+			((aClass methodDictionary values) sorted: [:a :b | a selector <= b selector]) do: [:method |
+				(method category match: '^\*', name) ifTrue: [
+					self exportMethod: method of: aClass on: aStream ]]]]
 ! !
 
-!ChunkParser methodsFor: 'reading'!
+Exporter subclass: #ChunkExporter
+	instanceVariableNames: ''
+	package: 'Compiler'!
 
-nextChunk
-	"The chunk format (Smalltalk Interchange Format or Fileout format)
-	is a trivial format but can be a bit tricky to understand:
-		- Uses the exclamation mark as delimiter of chunks.
-		- Inside a chunk a normal exclamation mark must be doubled.
-		- A non empty chunk must be a valid Smalltalk expression.
-		- A chunk on top level with a preceding empty chunk is an instruction chunk:
-			- The object created by the expression then takes over reading chunks.
+!ChunkExporter methodsFor: 'not yet classified'!
 
-	This metod returns next chunk as a String (trimmed), empty String (all whitespace) or nil."
+chunkEscape: aString
+	"Replace all occurrences of !! with !!!! and trim at both ends."
 
-	| char result chunk |
-	result := '' writeStream.
-        [char := stream next.
-        char notNil] whileTrue: [
-                 char = '!!' ifTrue: [
-                         stream peek = '!!'
-                                ifTrue: [stream next "skipping the escape double"]
-                                ifFalse: [^result contents trimBoth  "chunk end marker found"]].
-                 result nextPut: char].
-	^nil "a chunk needs to end with !!"
-! !
+	^(aString replace: '!!' with: '!!!!') trimBoth
+!
 
-!ChunkParser class methodsFor: 'not yet classified'!
+classNameFor: aClass
+	^aClass isMetaclass
+	    ifTrue: [aClass instanceClass name, ' class']
+	    ifFalse: [
+		aClass isNil
+		    ifTrue: ['nil']
+		    ifFalse: [aClass name]]
+!
 
-on: aStream
-	^self new stream: aStream
-! !
+exportDefinitionOf: aClass on: aStream
+    "Chunk format."
+
+    aStream 
+        nextPutAll: (self classNameFor: aClass superclass);
+        nextPutAll: ' subclass: #', (self classNameFor: aClass); lf;
+        nextPutAll: '	instanceVariableNames: '''.
+    aClass instanceVariableNames 
+        do: [:each | aStream nextPutAll: each]
+        separatedBy: [aStream nextPutAll: ' '].
+    aStream 
+        nextPutAll: ''''; lf;
+        nextPutAll: '	package: ''', aClass category, '''!!'; lf.
+    aClass comment notEmpty ifTrue: [
+        aStream 
+        nextPutAll: '!!', (self classNameFor: aClass), ' commentStamp!!';lf;
+        nextPutAll: (self chunkEscape: aClass comment), '!!';lf].
+    aStream lf
+!
+
+exportMetaDefinitionOf: aClass on: aStream
+
+	aClass class instanceVariableNames isEmpty ifFalse: [
+		aStream 
+		    nextPutAll: (self classNameFor: aClass class);
+		    nextPutAll: ' instanceVariableNames: '''.
+		aClass class instanceVariableNames 
+		    do: [:each | aStream nextPutAll: each]
+		    separatedBy: [aStream nextPutAll: ' '].
+		aStream	
+		    nextPutAll: '''!!'; lf; lf]
+!
+
+exportMethod: aMethod of: aClass on: aStream
+	aStream 
+		lf; lf; nextPutAll: (self chunkEscape: aMethod source); lf;
+		nextPutAll: '!!'
+!
+
+exportMethods: methods category: category of: aClass on: aStream
+	"Issue #143: sort methods alphabetically"
+
+	aStream
+		nextPutAll: '!!', (self classNameFor: aClass);
+		nextPutAll: ' methodsFor: ''', category, '''!!'.
+		(methods sorted: [:a :b | a selector <= b selector]) do: [:each |
+				self exportMethod: each of: aClass on: aStream].
+	aStream nextPutAll: ' !!'; lf; lf
+!
+
+exportMethodsOf: aClass on: aStream
+	"Issue #143: sort protocol alphabetically"
+
+	| map |
+	map := Dictionary new.
+	aClass protocolsDo: [:category :methods | 
+		(category match: '^\*') ifFalse: [ map at: category put: methods ]].
+	(map keys sorted: [:a :b | a <= b ]) do: [:category | | methods |
+		methods := map at: category.
+		self
+			exportMethods: methods
+			category: category
+			of: aClass
+			on: aStream ]
+!
+
+exportPackageDefinitionOf: package on: aStream
+	"Chunk format."
+
+	aStream 
+	    nextPutAll: 'Smalltalk current createPackage: ''', package name,
+		''' properties: ', package properties storeString, '!!'; lf.
+!
+
+exportPackageExtensionsOf: package on: aStream
+	"We need to override this one too since we need to group
+	all methods in a given protocol under a leading methodsFor: chunk
+	for that class."
+
+	"Issue #143: sort protocol alphabetically"
+
+	| name map |
+	name := package name.
+	(Package sortedClasses: Smalltalk current classes) do: [:each |
+		{each. each class} do: [:aClass |
+			map := Dictionary new.
+			aClass protocolsDo: [:category :methods | 
+				(category match: '^\*', name) ifTrue: [ map at: category put: methods ]].
+			(map keys sorted: [:a :b | a <= b ]) do: [:category | | methods |
+				methods := map at: category.	
+				self exportMethods: methods category: category of: aClass on: aStream ]]]
+! !
+
+Exporter subclass: #StrippedExporter
+	instanceVariableNames: ''
+	package: 'Compiler'!
+
+!StrippedExporter methodsFor: 'private'!
+
+exportDefinitionOf: aClass on: aStream
+	aStream 
+	    nextPutAll: 'smalltalk.addClass(';
+	    nextPutAll: '''', (self classNameFor: aClass), ''', ';
+	    nextPutAll: 'smalltalk.', (self classNameFor: aClass superclass);
+	    nextPutAll: ', ['.
+	aClass instanceVariableNames 
+	    do: [:each | aStream nextPutAll: '''', each, '''']
+	    separatedBy: [aStream nextPutAll: ', '].
+	aStream	
+	    nextPutAll: '], ''';
+	    nextPutAll: aClass category, '''';
+	    nextPutAll: ');'.
+	aStream lf
+!
+
+exportMethod: aMethod of: aClass on: aStream
+	aStream 
+		nextPutAll: 'smalltalk.addMethod(';lf;
+		nextPutAll: aMethod selector asSelector asJavascript, ',';lf;
+		nextPutAll: 'smalltalk.method({';lf;
+		nextPutAll: 'selector: ', aMethod selector asJavascript, ',';lf;
+		nextPutAll: 'fn: ', aMethod fn compiledSource;lf;
+		nextPutAll: '}),';lf;
+		nextPutAll: 'smalltalk.', (self classNameFor: aClass);
+		nextPutAll: ');';lf;lf
+! !
+
+Object subclass: #Importer
+	instanceVariableNames: ''
+	package: 'Compiler'!
+
+!Importer methodsFor: 'fileIn'!
+
+import: aStream
+    | chunk result parser lastEmpty |
+    parser := ChunkParser on: aStream.
+    lastEmpty := false.
+    [chunk := parser nextChunk.
+     chunk isNil] whileFalse: [
+        chunk isEmpty
+       		ifTrue: [lastEmpty := true]
+       		ifFalse: [
+        		result := Compiler new evaluateExpression: chunk.
+        		lastEmpty 
+            			ifTrue: [
+                                  	lastEmpty := false.
+                                  	result scanFrom: parser]]]
+! !
 
 Object subclass: #Node
 	instanceVariableNames: 'nodes'
-	category: 'Compiler'!
+	package: 'Compiler'!
 
 !Node methodsFor: 'accessing'!
 
-nodes
-	^nodes ifNil: [nodes := Array new]
-!
-
 addNode: aNode
 	self nodes add: aNode
+!
+
+nodes
+	^nodes ifNil: [nodes := Array new]
 ! !
 
 !Node methodsFor: 'building'!
@@ -285,15 +487,15 @@ nodes: aCollection
 
 !Node methodsFor: 'testing'!
 
-isValueNode
+isBlockNode
 	^false
 !
 
-isBlockNode
+isBlockSequenceNode
 	^false
 !
 
-isBlockSequenceNode
+isValueNode
 	^false
 ! !
 
@@ -303,227 +505,181 @@ accept: aVisitor
 	aVisitor visitNode: self
 ! !
 
-Node subclass: #SequenceNode
-	instanceVariableNames: 'temps'
-	category: 'Compiler'!
+Node subclass: #AssignmentNode
+	instanceVariableNames: 'left right'
+	package: 'Compiler'!
 
-!SequenceNode methodsFor: 'accessing'!
+!AssignmentNode methodsFor: 'accessing'!
 
-temps
-	^temps ifNil: [#()]
+left
+	^left
 !
 
-temps: aCollection
-	temps := aCollection
-! !
+left: aNode
+	left := aNode.
+	left assigned: true
+!
 
-!SequenceNode methodsFor: 'testing'!
+right
+	^right
+!
 
-asBlockSequenceNode
-	^BlockSequenceNode new
-	    nodes: self nodes;
-	    temps: self temps;
-	    yourself
+right: aNode
+	right := aNode
 ! !
 
-!SequenceNode methodsFor: 'visiting'!
+!AssignmentNode methodsFor: 'visiting'!
 
 accept: aVisitor
-	aVisitor visitSequenceNode: self
+	aVisitor visitAssignmentNode: self
 ! !
 
-Node subclass: #DynamicDictionaryNode
-	instanceVariableNames: ''
-	category: 'Compiler'!
+Node subclass: #BlockNode
+	instanceVariableNames: 'parameters inlined'
+	package: 'Compiler'!
 
-!DynamicDictionaryNode methodsFor: 'visiting'!
+!BlockNode methodsFor: 'accessing'!
 
-accept: aVisitor
-	aVisitor visitDynamicDictionaryNode: self
+inlined
+	^inlined ifNil: [false]
+!
+
+inlined: aBoolean
+	inlined := aBoolean
+!
+
+parameters
+	^parameters ifNil: [parameters := Array new]
+!
+
+parameters: aCollection
+	parameters := aCollection
 ! !
 
-Node subclass: #ReturnNode
-	instanceVariableNames: ''
-	category: 'Compiler'!
+!BlockNode methodsFor: 'testing'!
 
-!ReturnNode methodsFor: 'visiting'!
+isBlockNode
+	^true
+! !
+
+!BlockNode methodsFor: 'visiting'!
 
 accept: aVisitor
-	aVisitor visitReturnNode: self
+	aVisitor visitBlockNode: self
 ! !
 
-Node subclass: #ValueNode
-	instanceVariableNames: 'value'
-	category: 'Compiler'!
+Node subclass: #CascadeNode
+	instanceVariableNames: 'receiver'
+	package: 'Compiler'!
 
-!ValueNode methodsFor: 'accessing'!
+!CascadeNode methodsFor: 'accessing'!
 
-value
-	^value
+receiver
+	^receiver
 !
 
-value: anObject
-	value := anObject
+receiver: aNode
+	receiver := aNode
 ! !
 
-!ValueNode methodsFor: 'testing'!
+!CascadeNode methodsFor: 'visiting'!
 
-isValueNode
-	^true
+accept: aVisitor
+	aVisitor visitCascadeNode: self
 ! !
 
-!ValueNode methodsFor: 'visiting'!
+Node subclass: #DynamicArrayNode
+	instanceVariableNames: ''
+	package: 'Compiler'!
+
+!DynamicArrayNode methodsFor: 'visiting'!
 
 accept: aVisitor
-	aVisitor visitValueNode: self
+	aVisitor visitDynamicArrayNode: self
 ! !
 
-ValueNode subclass: #VariableNode
-	instanceVariableNames: 'assigned'
-	category: 'Compiler'!
+Node subclass: #DynamicDictionaryNode
+	instanceVariableNames: ''
+	package: 'Compiler'!
 
-!VariableNode methodsFor: 'accessing'!
+!DynamicDictionaryNode methodsFor: 'visiting'!
 
-assigned
-	^assigned ifNil: [false]
+accept: aVisitor
+	aVisitor visitDynamicDictionaryNode: self
+! !
+
+Node subclass: #JSStatementNode
+	instanceVariableNames: 'source'
+	package: 'Compiler'!
+
+!JSStatementNode methodsFor: 'accessing'!
+
+source
+	^source ifNil: ['']
 !
 
-assigned: aBoolean
-	assigned := aBoolean
+source: aString
+	source := aString
 ! !
 
-!VariableNode methodsFor: 'visiting'!
+!JSStatementNode methodsFor: 'visiting'!
 
 accept: aVisitor
-	aVisitor visitVariableNode: self
+	aVisitor visitJSStatementNode: self
 ! !
 
-Exporter subclass: #ChunkExporter
-	instanceVariableNames: ''
-	category: 'Compiler'!
+Node subclass: #MethodNode
+	instanceVariableNames: 'selector arguments source'
+	package: 'Compiler'!
 
-!ChunkExporter methodsFor: 'not yet classified'!
+!MethodNode methodsFor: 'accessing'!
 
-exportDefinitionOf: aClass on: aStream
-	"Chunk format."
+arguments
+	^arguments ifNil: [#()]
+!
 
-	aStream 
-	    nextPutAll: (self classNameFor: aClass superclass);
-	    nextPutAll: ' subclass: #', (self classNameFor: aClass); lf;
-	    nextPutAll: '	instanceVariableNames: '''.
-	aClass instanceVariableNames 
-	    do: [:each | aStream nextPutAll: each]
-	    separatedBy: [aStream nextPutAll: ' '].
-	aStream	
-	    nextPutAll: ''''; lf;
-	    nextPutAll: '	category: ''', aClass category, '''!!'; lf.
- 	aClass comment notEmpty ifTrue: [
-	    aStream 
-		nextPutAll: '!!', (self classNameFor: aClass), ' commentStamp!!';lf;
-		nextPutAll: (self chunkEscape: aClass comment), '!!';lf].
-	aStream lf
+arguments: aCollection
+	arguments := aCollection
 !
 
-exportMethod: aMethod of: aClass on: aStream
-	aStream 
-		lf; lf; nextPutAll: (self chunkEscape: aMethod source); lf;
-		nextPutAll: '!!'
-!
-
-exportMethodsOf: aClass on: aStream
-
-   aClass protocolsDo: [:category :methods |
-	(category match: '^\*') ifFalse: [ 
-		self
-			exportMethods: methods
-			category: category
-			of: aClass
-			on: aStream]]
-!
-
-exportMetaDefinitionOf: aClass on: aStream
-
-	aClass class instanceVariableNames isEmpty ifFalse: [
-		aStream 
-		    nextPutAll: (self classNameFor: aClass class);
-		    nextPutAll: ' instanceVariableNames: '''.
-		aClass class instanceVariableNames 
-		    do: [:each | aStream nextPutAll: each]
-		    separatedBy: [aStream nextPutAll: ' '].
-		aStream	
-		    nextPutAll: '''!!'; lf; lf]
-!
-
-classNameFor: aClass
-	^aClass isMetaclass
-	    ifTrue: [aClass instanceClass name, ' class']
-	    ifFalse: [
-		aClass isNil
-		    ifTrue: ['nil']
-		    ifFalse: [aClass name]]
+selector
+	^selector
 !
 
-chunkEscape: aString
-	"Replace all occurrences of !! with !!!! and trim at both ends."
-
-	^(aString replace: '!!' with: '!!!!') trimBoth
+selector: aString
+	selector := aString
 !
 
-exportMethods: methods category: category of: aClass on: aStream
-
-	aStream
-		nextPutAll: '!!', (self classNameFor: aClass);
-		nextPutAll: ' methodsFor: ''', category, '''!!'.
-    	methods do: [:each |
-		self exportMethod: each of: aClass on: aStream].
-	aStream nextPutAll: ' !!'; lf; lf
+source
+	^source
 !
 
-exportPackageExtensionsOf: package on: aStream
-	"We need to override this one too since we need to group
-	all methods in a given protocol under a leading methodsFor: chunk
-	for that class."
-
-	| name |
-	name := package name.
-	Smalltalk current classes, (Smalltalk current classes collect: [:each | each class]) do: [:each |
-		each protocolsDo: [:category :methods |
-			category = ('*', name) ifTrue: [
-				self exportMethods: methods category: category of: each on: aStream]]]
-!
+source: aString
+	source := aString
+! !
 
-exportPackageDefinitionOf: package on: aStream
-	"Chunk format."
+!MethodNode methodsFor: 'visiting'!
 
-	aStream 
-	    nextPutAll: 'Smalltalk current createPackage: ''', package name,
-		''' properties: ', package properties storeString, '!!'; lf.
+accept: aVisitor
+	aVisitor visitMethodNode: self
 ! !
 
-VariableNode subclass: #ClassReferenceNode
+Node subclass: #ReturnNode
 	instanceVariableNames: ''
-	category: 'Compiler'!
+	package: 'Compiler'!
 
-!ClassReferenceNode methodsFor: 'visiting'!
+!ReturnNode methodsFor: 'visiting'!
 
 accept: aVisitor
-	aVisitor visitClassReferenceNode: self
+	aVisitor visitReturnNode: self
 ! !
 
 Node subclass: #SendNode
 	instanceVariableNames: 'selector arguments receiver'
-	category: 'Compiler'!
+	package: 'Compiler'!
 
 !SendNode methodsFor: 'accessing'!
 
-selector
-	^selector
-!
-
-selector: aString
-	selector := aString
-!
-
 arguments
 	^arguments ifNil: [arguments := #()]
 !
@@ -532,6 +688,18 @@ arguments: aCollection
 	arguments := aCollection
 !
 
+cascadeNodeWithMessages: aCollection
+	| first |
+	first := SendNode new
+	    selector: self selector;
+	    arguments: self arguments;
+	    yourself.
+	^CascadeNode new
+	    receiver: self receiver;
+	    nodes: (Array with: first), aCollection;
+	    yourself
+!
+
 receiver
 	^receiver
 !
@@ -540,6 +708,14 @@ receiver: aNode
 	receiver := aNode
 !
 
+selector
+	^selector
+!
+
+selector: aString
+	selector := aString
+!
+
 valueForReceiver: anObject
 	^SendNode new
 	    receiver: (self receiver 
@@ -548,18 +724,6 @@ valueForReceiver: anObject
 	    selector: self selector;
 	    arguments: self arguments;
 	    yourself
-!
-
-cascadeNodeWithMessages: aCollection
-	| first |
-	first := SendNode new
-	    selector: self selector;
-	    arguments: self arguments;
-	    yourself.
-	^CascadeNode new
-	    receiver: self receiver;
-	    nodes: (Array with: first), aCollection;
-	    yourself
 ! !
 
 !SendNode methodsFor: 'visiting'!
@@ -568,199 +732,257 @@ accept: aVisitor
 	aVisitor visitSendNode: self
 ! !
 
-Node subclass: #JSStatementNode
-	instanceVariableNames: 'source'
-	category: 'Compiler'!
+Node subclass: #SequenceNode
+	instanceVariableNames: 'temps'
+	package: 'Compiler'!
 
-!JSStatementNode methodsFor: 'accessing'!
+!SequenceNode methodsFor: 'accessing'!
 
-source
-	^source ifNil: ['']
+temps
+	^temps ifNil: [#()]
 !
 
-source: aString
-	source := aString
+temps: aCollection
+	temps := aCollection
 ! !
 
-!JSStatementNode methodsFor: 'visiting'!
+!SequenceNode methodsFor: 'testing'!
+
+asBlockSequenceNode
+	^BlockSequenceNode new
+	    nodes: self nodes;
+	    temps: self temps;
+	    yourself
+! !
+
+!SequenceNode methodsFor: 'visiting'!
 
 accept: aVisitor
-	aVisitor visitJSStatementNode: self
+	aVisitor visitSequenceNode: self
 ! !
 
-Node subclass: #AssignmentNode
-	instanceVariableNames: 'left right'
-	category: 'Compiler'!
+SequenceNode subclass: #BlockSequenceNode
+	instanceVariableNames: ''
+	package: 'Compiler'!
 
-!AssignmentNode methodsFor: 'accessing'!
+!BlockSequenceNode methodsFor: 'testing'!
 
-left
-	^left
-!
+isBlockSequenceNode
+	^true
+! !
 
-left: aNode
-	left := aNode.
-	left assigned: true
+!BlockSequenceNode methodsFor: 'visiting'!
+
+accept: aVisitor
+	aVisitor visitBlockSequenceNode: self
+! !
+
+Node subclass: #ValueNode
+	instanceVariableNames: 'value'
+	package: 'Compiler'!
+
+!ValueNode methodsFor: 'accessing'!
+
+value
+	^value
 !
 
-right
-	^right
+value: anObject
+	value := anObject
+! !
+
+!ValueNode methodsFor: 'testing'!
+
+isValueNode
+	^true
+! !
+
+!ValueNode methodsFor: 'visiting'!
+
+accept: aVisitor
+	aVisitor visitValueNode: self
+! !
+
+ValueNode subclass: #VariableNode
+	instanceVariableNames: 'assigned'
+	package: 'Compiler'!
+
+!VariableNode methodsFor: 'accessing'!
+
+assigned
+	^assigned ifNil: [false]
 !
 
-right: aNode
-	right := aNode
+assigned: aBoolean
+	assigned := aBoolean
 ! !
 
-!AssignmentNode methodsFor: 'visiting'!
+!VariableNode methodsFor: 'visiting'!
 
 accept: aVisitor
-	aVisitor visitAssignmentNode: self
+	aVisitor visitVariableNode: self
 ! !
 
-Node subclass: #DynamicArrayNode
+VariableNode subclass: #ClassReferenceNode
 	instanceVariableNames: ''
-	category: 'Compiler'!
+	package: 'Compiler'!
 
-!DynamicArrayNode methodsFor: 'visiting'!
+!ClassReferenceNode methodsFor: 'visiting'!
 
 accept: aVisitor
-	aVisitor visitDynamicArrayNode: self
+	aVisitor visitClassReferenceNode: self
 ! !
 
-NodeVisitor subclass: #Compiler
-	instanceVariableNames: 'stream nestedBlocks earlyReturn currentClass currentSelector unknownVariables tempVariables messageSends referencedClasses classReferenced source argVariables'
-	category: 'Compiler'!
+Object subclass: #NodeVisitor
+	instanceVariableNames: ''
+	package: 'Compiler'!
 
-!Compiler methodsFor: 'accessing'!
+!NodeVisitor methodsFor: 'visiting'!
 
-parser
-	^SmalltalkParser new
+visit: aNode
+	aNode accept: self
 !
 
-currentClass
-	^currentClass
+visitAssignmentNode: aNode
+	self visitNode: aNode
 !
 
-currentClass: aClass
-	currentClass := aClass
+visitBlockNode: aNode
+	self visitNode: aNode
 !
 
-unknownVariables
-	^unknownVariables copy
+visitBlockSequenceNode: aNode
+	self visitNode: aNode
 !
 
-pseudoVariables
-	^#('self' 'super' 'true' 'false' 'nil' 'thisContext')
+visitCascadeNode: aNode
+	self visitNode: aNode
 !
 
-tempVariables
-	^tempVariables copy
+visitClassReferenceNode: aNode
+	self visitNode: aNode
 !
 
-knownVariables
-	^self pseudoVariables 
-		addAll: self tempVariables;
-		addAll: self argVariables;
-		yourself
+visitDynamicArrayNode: aNode
+	self visitNode: aNode
 !
 
-classNameFor: aClass
-	^aClass isMetaclass
-	    ifTrue: [aClass instanceClass name, '.klass']
-	    ifFalse: [
-		aClass isNil
-		    ifTrue: ['nil']
-		    ifFalse: [aClass name]]
+visitDynamicDictionaryNode: aNode
+	self visitNode: aNode
 !
 
-source
-	^source ifNil: ['']
+visitJSStatementNode: aNode
+	self visitNode: aNode
 !
 
-source: aString
-	source := aString
+visitMethodNode: aNode
+	self visitNode: aNode
 !
 
-argVariables
-	^argVariables copy
+visitNode: aNode
 !
 
-safeVariableNameFor: aString
-	^(Smalltalk current reservedWords includes: aString)
-		ifTrue: [aString, '_']
-		ifFalse: [aString]
-! !
+visitReturnNode: aNode
+	self visitNode: aNode
+!
 
-!Compiler methodsFor: 'compiling'!
+visitSendNode: aNode
+	self visitNode: aNode
+!
 
-loadExpression: aString
-	| result |
-	DoIt addCompiledMethod: (self eval: (self compileExpression: aString)).
-	result := DoIt new doIt.
-	DoIt removeCompiledMethod: (DoIt methodDictionary at: 'doIt').
-	^result
+visitSequenceNode: aNode
+	self visitNode: aNode
 !
 
-load: aString forClass: aClass
-	| compiled |
-	compiled := self eval: (self compile: aString forClass: aClass).
-	self setupClass: aClass.
-	^compiled
+visitValueNode: aNode
+	self visitNode: aNode
 !
 
-compile: aString forClass: aClass
-	self currentClass: aClass.
-	self source: aString.
-	^self compile: aString
+visitVariableNode: aNode
+	self visitNode: aNode
+! !
+
+NodeVisitor subclass: #AbstractCodeGenerator
+	instanceVariableNames: 'currentClass source'
+	package: 'Compiler'!
+
+!AbstractCodeGenerator methodsFor: 'accessing'!
+
+classNameFor: aClass
+	^aClass isMetaclass
+	    ifTrue: [aClass instanceClass name, '.klass']
+	    ifFalse: [
+		aClass isNil
+		    ifTrue: ['nil']
+		    ifFalse: [aClass name]]
 !
 
-compileExpression: aString
-	self currentClass: DoIt.
-	self source: 'doIt ^[', aString, '] value'.
-	^self compileNode: (self parse: self source)
+currentClass
+	^currentClass
 !
 
-eval: aString
-	<return eval(aString)>
+currentClass: aClass
+	currentClass := aClass
 !
 
-compile: aString
-	^self compileNode: (self parse: aString)
+pseudoVariables
+	^#('self' 'super' 'true' 'false' 'nil' 'thisContext')
 !
 
-compileNode: aNode
-	stream := '' writeStream.
-	self visit: aNode.
-	^stream contents
+safeVariableNameFor: aString
+	^(Smalltalk current reservedWords includes: aString)
+		ifTrue: [aString, '_']
+		ifFalse: [aString]
 !
 
-parse: aString
-    ^Smalltalk current parse: aString
+source
+	^source ifNil: ['']
 !
 
-parseExpression: aString
-    ^self parse: 'doIt ^[', aString, '] value'
+source: aString
+	source := aString
+! !
+
+!AbstractCodeGenerator methodsFor: 'compiling'!
+
+compileNode: aNode
+	self subclassResponsibility
+! !
+
+AbstractCodeGenerator subclass: #FunCodeGenerator
+	instanceVariableNames: 'stream nestedBlocks earlyReturn currentSelector unknownVariables tempVariables messageSends referencedClasses classReferenced argVariables'
+	package: 'Compiler'!
+
+!FunCodeGenerator methodsFor: 'accessing'!
+
+argVariables
+	^argVariables copy
 !
 
-recompile: aClass
-	aClass methodDictionary do: [:each || method |
-		method := self load: each source forClass: aClass.
-		method category: each category.
-		aClass addCompiledMethod: method].
-	aClass isMetaclass ifFalse: [self recompile: aClass class]
+knownVariables
+	^self pseudoVariables 
+		addAll: self tempVariables;
+		addAll: self argVariables;
+		yourself
 !
 
-recompileAll
-	Smalltalk current classes do: [:each |
-		Transcript show: each; cr.
-		[self recompile: each] valueWithTimeout: 100]
+tempVariables
+	^tempVariables copy
 !
 
-setupClass: aClass
-	<smalltalk.init(aClass)>
+unknownVariables
+	^unknownVariables copy
+! !
+
+!FunCodeGenerator methodsFor: 'compiling'!
+
+compileNode: aNode
+	stream := '' writeStream.
+	self visit: aNode.
+	^stream contents
 ! !
 
-!Compiler methodsFor: 'initialization'!
+!FunCodeGenerator methodsFor: 'initialization'!
 
 initialize
 	super initialize.
@@ -772,12 +994,107 @@ initialize
 	classReferenced := #()
 ! !
 
-!Compiler methodsFor: 'optimizations'!
+!FunCodeGenerator methodsFor: 'optimizations'!
 
 checkClass: aClassName for: receiver
         stream nextPutAll: '((($receiver = ', receiver, ').klass === smalltalk.', aClassName, ') ? '
 !
 
+inline: aSelector receiver: receiver argumentNodes: aCollection
+        | inlined |
+        inlined := false.
+
+	"-- Booleans --"
+
+	(aSelector = 'ifFalse:') ifTrue: [
+		aCollection first isBlockNode ifTrue: [
+                	self checkClass: 'Boolean' for: receiver.
+                	stream nextPutAll: '(!! $receiver ? '.
+                	self visit: aCollection first.
+          		stream nextPutAll: '() : nil)'.
+                	inlined := true]].
+
+	(aSelector = 'ifTrue:') ifTrue: [
+		aCollection first isBlockNode ifTrue: [
+                	self checkClass: 'Boolean' for: receiver.
+                	stream nextPutAll: '($receiver ? '.
+                	self visit: aCollection first.
+          		stream nextPutAll: '() : nil)'.
+                	inlined := true]].
+
+	(aSelector = 'ifTrue:ifFalse:') ifTrue: [
+		(aCollection first isBlockNode and: [aCollection second isBlockNode]) ifTrue: [
+                	self checkClass: 'Boolean' for: receiver.
+                	stream nextPutAll: '($receiver ? '.
+                	self visit: aCollection first.
+          		stream nextPutAll: '() : '.
+          		self visit: aCollection second.
+          		stream nextPutAll: '())'.
+                	inlined := true]].
+
+	(aSelector = 'ifFalse:ifTrue:') ifTrue: [
+		(aCollection first isBlockNode and: [aCollection second isBlockNode]) ifTrue: [
+                	self checkClass: 'Boolean' for: receiver.
+                	stream nextPutAll: '(!! $receiver ? '.
+                	self visit: aCollection first.
+          		stream nextPutAll: '() : '.
+          		self visit: aCollection second.
+          		stream nextPutAll: '())'.
+                	inlined := true]].
+
+	"-- Numbers --"
+
+	(aSelector = '<') ifTrue: [
+                self checkClass: 'Number' for: receiver.
+                stream nextPutAll: '$receiver <'.
+                self visit: aCollection first.
+                inlined := true].
+
+	(aSelector = '<=') ifTrue: [
+                self checkClass: 'Number' for: receiver.
+                stream nextPutAll: '$receiver <='.
+                self visit: aCollection first.
+                inlined := true].
+
+	(aSelector = '>') ifTrue: [ 
+                self checkClass: 'Number' for: receiver.
+                stream nextPutAll: '$receiver >'.
+                self visit: aCollection first.
+                inlined := true].
+
+	(aSelector = '>=') ifTrue: [
+                self checkClass: 'Number' for: receiver.
+                stream nextPutAll: '$receiver >='.
+                self visit: aCollection first.
+                inlined := true].
+
+        (aSelector = '+') ifTrue: [
+                self checkClass: 'Number' for: receiver.
+                stream nextPutAll: '$receiver +'.
+                self visit: aCollection first.
+                inlined := true].
+
+        (aSelector = '-') ifTrue: [
+                self checkClass: 'Number' for: receiver.
+                stream nextPutAll: '$receiver -'.
+                self visit: aCollection first.
+                inlined := true].
+
+        (aSelector = '*') ifTrue: [
+                self checkClass: 'Number' for: receiver.
+                stream nextPutAll: '$receiver *'.
+                self visit: aCollection first.
+                inlined := true].
+
+        (aSelector = '/') ifTrue: [
+                self checkClass: 'Number' for: receiver.
+                stream nextPutAll: '$receiver /'.
+                self visit: aCollection first.
+                inlined := true].
+
+        ^inlined
+!
+
 inlineLiteral: aSelector receiverNode: anObject argumentNodes: aCollection
         | inlined |
         inlined := false.
@@ -923,113 +1240,124 @@ isNode: aNode ofClass: aClass
 	^aNode isValueNode and: [
           	aNode value class = aClass or: [
           		aNode value = 'self' and: [self currentClass = aClass]]]
-!
+! !
 
-inline: aSelector receiver: receiver argumentNodes: aCollection
-        | inlined |
-        inlined := false.
+!FunCodeGenerator methodsFor: 'testing'!
 
-	"-- Booleans --"
+performOptimizations
+	^self class performOptimizations
+! !
 
-	(aSelector = 'ifFalse:') ifTrue: [
-		aCollection first isBlockNode ifTrue: [
-                	self checkClass: 'Boolean' for: receiver.
-                	stream nextPutAll: '(!! $receiver ? '.
-                	self visit: aCollection first.
-          		stream nextPutAll: '() : nil)'.
-                	inlined := true]].
+!FunCodeGenerator methodsFor: 'visiting'!
 
-	(aSelector = 'ifTrue:') ifTrue: [
-		aCollection first isBlockNode ifTrue: [
-                	self checkClass: 'Boolean' for: receiver.
-                	stream nextPutAll: '($receiver ? '.
-                	self visit: aCollection first.
-          		stream nextPutAll: '() : nil)'.
-                	inlined := true]].
+send: aSelector to: aReceiver arguments: aCollection superSend: aBoolean
+	^String streamContents: [:str || tmp |
+        	tmp := stream.
+		str nextPutAll: 'smalltalk.send('.
+		str nextPutAll: aReceiver.
+		str nextPutAll: ', "', aSelector asSelector, '", ['.
+                stream := str.
+		aCollection
+	    		do: [:each | self visit: each]
+	    		separatedBy: [stream nextPutAll: ', '].
+                stream := tmp.
+                str nextPutAll: ']'.
+		aBoolean ifTrue: [
+			str nextPutAll: ', smalltalk.', (self classNameFor: self currentClass), '.superclass || nil'].
+		str nextPutAll: ')']
+!
 
-	(aSelector = 'ifTrue:ifFalse:') ifTrue: [
-		(aCollection first isBlockNode and: [aCollection second isBlockNode]) ifTrue: [
-                	self checkClass: 'Boolean' for: receiver.
-                	stream nextPutAll: '($receiver ? '.
-                	self visit: aCollection first.
-          		stream nextPutAll: '() : '.
-          		self visit: aCollection second.
-          		stream nextPutAll: '())'.
-                	inlined := true]].
+visit: aNode
+	aNode accept: self
+!
 
-	(aSelector = 'ifFalse:ifTrue:') ifTrue: [
-		(aCollection first isBlockNode and: [aCollection second isBlockNode]) ifTrue: [
-                	self checkClass: 'Boolean' for: receiver.
-                	stream nextPutAll: '(!! $receiver ? '.
-                	self visit: aCollection first.
-          		stream nextPutAll: '() : '.
-          		self visit: aCollection second.
-          		stream nextPutAll: '())'.
-                	inlined := true]].
-
-	"-- Numbers --"
-
-	(aSelector = '<') ifTrue: [
-                self checkClass: 'Number' for: receiver.
-                stream nextPutAll: '$receiver <'.
-                self visit: aCollection first.
-                inlined := true].
-
-	(aSelector = '<=') ifTrue: [
-                self checkClass: 'Number' for: receiver.
-                stream nextPutAll: '$receiver <='.
-                self visit: aCollection first.
-                inlined := true].
-
-	(aSelector = '>') ifTrue: [ 
-                self checkClass: 'Number' for: receiver.
-                stream nextPutAll: '$receiver >'.
-                self visit: aCollection first.
-                inlined := true].
-
-	(aSelector = '>=') ifTrue: [
-                self checkClass: 'Number' for: receiver.
-                stream nextPutAll: '$receiver >='.
-                self visit: aCollection first.
-                inlined := true].
-
-        (aSelector = '+') ifTrue: [
-                self checkClass: 'Number' for: receiver.
-                stream nextPutAll: '$receiver +'.
-                self visit: aCollection first.
-                inlined := true].
+visitAssignmentNode: aNode
+	stream nextPutAll: '('.
+	self visit: aNode left.
+	stream nextPutAll: '='.
+	self visit: aNode right.
+	stream nextPutAll: ')'
+!
 
-        (aSelector = '-') ifTrue: [
-                self checkClass: 'Number' for: receiver.
-                stream nextPutAll: '$receiver -'.
-                self visit: aCollection first.
-                inlined := true].
+visitBlockNode: aNode
+	stream nextPutAll: '(function('.
+	aNode parameters 
+	    do: [:each |
+		tempVariables add: each.
+		stream nextPutAll: each]
+	    separatedBy: [stream nextPutAll: ', '].
+	stream nextPutAll: '){'.
+	aNode nodes do: [:each | self visit: each].
+	stream nextPutAll: '})'
+!
 
-        (aSelector = '*') ifTrue: [
-                self checkClass: 'Number' for: receiver.
-                stream nextPutAll: '$receiver *'.
-                self visit: aCollection first.
-                inlined := true].
+visitBlockSequenceNode: aNode
+	| index |
+	nestedBlocks := nestedBlocks + 1.
+	aNode nodes isEmpty
+	    ifTrue: [
+		stream nextPutAll: 'return nil;']
+	    ifFalse: [
+		aNode temps do: [:each | | temp |
+                    temp := self safeVariableNameFor: each.
+		    tempVariables add: temp.
+		    stream nextPutAll: 'var ', temp, '=nil;'; lf].
+		index := 0.
+		aNode nodes do: [:each |
+		    index := index + 1.
+		    index = aNode nodes size ifTrue: [
+			stream nextPutAll: 'return '].
+		    self visit: each.
+		    stream nextPutAll: ';']].
+	nestedBlocks := nestedBlocks - 1
+!
 
-        (aSelector = '/') ifTrue: [
-                self checkClass: 'Number' for: receiver.
-                stream nextPutAll: '$receiver /'.
-                self visit: aCollection first.
-                inlined := true].
+visitCascadeNode: aNode
+	| index |
+	index := 0.
+	(tempVariables includes: '$rec') ifFalse: [
+		tempVariables add: '$rec'].
+	stream nextPutAll: '(function($rec){'.
+	aNode nodes do: [:each |
+	    index := index + 1.
+	    index = aNode nodes size ifTrue: [
+		stream nextPutAll: 'return '].
+	    each receiver: (VariableNode new value: '$rec').
+	    self visit: each.
+	    stream nextPutAll: ';'].
+	stream nextPutAll: '})('.
+	self visit: aNode receiver.
+	stream nextPutAll: ')'
+!
 
-        ^inlined
-! !
+visitClassReferenceNode: aNode
+	(referencedClasses includes: aNode value) ifFalse: [
+		referencedClasses add: aNode value].
+	stream nextPutAll: '(smalltalk.', aNode value, ' || ', aNode value, ')'
+!
 
-!Compiler methodsFor: 'testing'!
+visitDynamicArrayNode: aNode
+	stream nextPutAll: '['.
+	aNode nodes 
+		do: [:each | self visit: each]
+		separatedBy: [stream nextPutAll: ','].
+	stream nextPutAll: ']'
+!
 
-performOptimizations
-	^self class performOptimizations
-! !
+visitDynamicDictionaryNode: aNode
+	stream nextPutAll: 'smalltalk.HashedCollection._fromPairs_(['.
+		aNode nodes 
+			do: [:each | self visit: each]
+			separatedBy: [stream nextPutAll: ','].
+		stream nextPutAll: '])'
+!
 
-!Compiler methodsFor: 'visiting'!
+visitFailure: aFailure
+	self error: aFailure asString
+!
 
-visit: aNode
-	aNode accept: self
+visitJSStatementNode: aNode
+	stream nextPutAll: aNode source
 !
 
 visitMethodNode: aNode
@@ -1045,7 +1373,7 @@ visitMethodNode: aNode
 	stream 
 	    nextPutAll: 'smalltalk.method({'; lf;
 	    nextPutAll: 'selector: "', aNode selector, '",'; lf.
-	stream nextPutAll: 'source: unescape("', self source escaped, '"),';lf.
+	stream nextPutAll: 'source: ', self source asJavascript, ',';lf.
 	stream nextPutAll: 'fn: function('.
 	aNode arguments 
 	    do: [:each | 
@@ -1060,14 +1388,14 @@ visitMethodNode: aNode
 	aNode nodes do: [:each |
 	    self visit: each].
 	earlyReturn ifTrue: [
-	    str nextPutAll: 'try{'].
+	    str nextPutAll: 'var $early={};'; lf; nextPutAll: 'try{'].
 	str nextPutAll: stream contents.
 	stream := str.
 	stream 
 	    lf; 
 	    nextPutAll: 'return self;'.
 	earlyReturn ifTrue: [
-	    stream lf; nextPutAll: '} catch(e) {if(e.name === ''stReturn'' && e.selector === ', currentSelector printString, '){return e.fn()} throw(e)}'].
+	    stream lf; nextPutAll: '} catch(e) {if(e===$early)return e[0]; throw e}'].
 	stream nextPutAll: '}'.
 	stream 
 		nextPutAll: ',', String lf, 'messageSends: ';
@@ -1081,65 +1409,18 @@ visitMethodNode: aNode
 	stream nextPutAll: '})'
 !
 
-visitBlockNode: aNode
-	stream nextPutAll: '(function('.
-	aNode parameters 
-	    do: [:each |
-		tempVariables add: each.
-		stream nextPutAll: each]
-	    separatedBy: [stream nextPutAll: ', '].
-	stream nextPutAll: '){'.
-	aNode nodes do: [:each | self visit: each].
-	stream nextPutAll: '})'
-!
-
-visitSequenceNode: aNode
-	aNode temps do: [:each || temp |
-            temp := self safeVariableNameFor: each.
-	    tempVariables add: temp.
-	    stream nextPutAll: 'var ', temp, '=nil;'; lf].
-	aNode nodes do: [:each |
-	    self visit: each.
-	    stream nextPutAll: ';']
-	    separatedBy: [stream lf]
-!
-
-visitBlockSequenceNode: aNode
-	| index |
-	nestedBlocks := nestedBlocks + 1.
-	aNode nodes isEmpty
-	    ifTrue: [
-		stream nextPutAll: 'return nil;']
-	    ifFalse: [
-		aNode temps do: [:each | | temp |
-                    temp := self safeVariableNameFor: each.
-		    tempVariables add: temp.
-		    stream nextPutAll: 'var ', temp, '=nil;'; lf].
-		index := 0.
-		aNode nodes do: [:each |
-		    index := index + 1.
-		    index = aNode nodes size ifTrue: [
-			stream nextPutAll: 'return '].
-		    self visit: each.
-		    stream nextPutAll: ';']].
-	nestedBlocks := nestedBlocks - 1
-!
-
 visitReturnNode: aNode
 	nestedBlocks > 0 ifTrue: [
 	    earlyReturn := true].
-	earlyReturn
+	nestedBlocks > 0
 	    ifTrue: [
 		stream
-		    nextPutAll: '(function(){throw(';
-		    nextPutAll: '{name: ''stReturn'', selector: ';
-		    nextPutAll: currentSelector printString;
-		    nextPutAll: ', fn: function(){return ']
+		    nextPutAll: '(function(){throw $early=[']
 	    ifFalse: [stream nextPutAll: 'return '].
 	aNode nodes do: [:each |
 	    self visit: each].
-	earlyReturn ifTrue: [
-	    stream nextPutAll: '}})})()']
+	nestedBlocks > 0 ifTrue: [
+	    stream nextPutAll: ']})()']
 !
 
 visitSendNode: aNode
@@ -1162,42 +1443,21 @@ visitSendNode: aNode
 		ifFalse: [stream nextPutAll: (self send: aNode selector to: receiver arguments: aNode arguments superSend: superSend)]
 !
 
-visitCascadeNode: aNode
-	| index |
-	index := 0.
-	(tempVariables includes: '$rec') ifFalse: [
-		tempVariables add: '$rec'].
-	stream nextPutAll: '(function($rec){'.
+visitSequenceNode: aNode
+	aNode temps do: [:each || temp |
+            temp := self safeVariableNameFor: each.
+	    tempVariables add: temp.
+	    stream nextPutAll: 'var ', temp, '=nil;'; lf].
 	aNode nodes do: [:each |
-	    index := index + 1.
-	    index = aNode nodes size ifTrue: [
-		stream nextPutAll: 'return '].
-	    each receiver: (VariableNode new value: '$rec').
 	    self visit: each.
-	    stream nextPutAll: ';'].
-	stream nextPutAll: '})('.
-	self visit: aNode receiver.
-	stream nextPutAll: ')'
+	    stream nextPutAll: ';']
+	    separatedBy: [stream lf]
 !
 
 visitValueNode: aNode
 	stream nextPutAll: aNode value asJavascript
 !
 
-visitAssignmentNode: aNode
-	stream nextPutAll: '('.
-	self visit: aNode left.
-	stream nextPutAll: '='.
-	self visit: aNode right.
-	stream nextPutAll: ')'
-!
-
-visitClassReferenceNode: aNode
-	(referencedClasses includes: aNode value) ifFalse: [
-		referencedClasses add: aNode value].
-	stream nextPutAll: '(smalltalk.', aNode value, ' || ', aNode value, ')'
-!
-
 visitVariableNode: aNode
 	| varName |
 	(self currentClass allInstanceVariableNames includes: aNode value) 
@@ -1214,52 +1474,11 @@ visitVariableNode: aNode
                                   	aNode value = 'thisContext'
                                   		ifTrue: [stream nextPutAll: '(smalltalk.getThisContext())']
                 				ifFalse: [stream nextPutAll: varName]]]
-!
-
-visitJSStatementNode: aNode
-	stream nextPutAll: (aNode source replace: '>>' with: '>')
-!
-
-visitFailure: aFailure
-	self error: aFailure asString
-!
-
-send: aSelector to: aReceiver arguments: aCollection superSend: aBoolean
-	^String streamContents: [:str || tmp |
-        	tmp := stream.
-		str nextPutAll: 'smalltalk.send('.
-		str nextPutAll: aReceiver.
-		str nextPutAll: ', "', aSelector asSelector, '", ['.
-                stream := str.
-		aCollection
-	    		do: [:each | self visit: each]
-	    		separatedBy: [stream nextPutAll: ', '].
-                stream := tmp.
-                str nextPutAll: ']'.
-		aBoolean ifTrue: [
-			str nextPutAll: ', smalltalk.', (self classNameFor: self currentClass superclass)].
-		str nextPutAll: ')']
-!
-
-visitDynamicArrayNode: aNode
-	stream nextPutAll: '['.
-	aNode nodes 
-		do: [:each | self visit: each]
-		separatedBy: [stream nextPutAll: ','].
-	stream nextPutAll: ']'
-!
-
-visitDynamicDictionaryNode: aNode
-	stream nextPutAll: 'smalltalk.HashedCollection._fromPairs_(['.
-		aNode nodes 
-			do: [:each | self visit: each]
-			separatedBy: [stream nextPutAll: ','].
-		stream nextPutAll: '])'
 ! !
 
-Compiler class instanceVariableNames: 'performOptimizations'!
+FunCodeGenerator class instanceVariableNames: 'performOptimizations'!
 
-!Compiler class methodsFor: 'accessing'!
+!FunCodeGenerator class methodsFor: 'accessing'!
 
 performOptimizations
 	^performOptimizations ifNil: [true]
@@ -1269,158 +1488,3 @@ performOptimizations: aBoolean
 	performOptimizations := aBoolean
 ! !
 
-!Compiler class methodsFor: 'compiling'!
-
-recompile: aClass
-	aClass methodDictionary do: [:each || method |
-		method := self new load: each source forClass: aClass.
-		method category: each category.
-		aClass addCompiledMethod: method].
-	aClass isMetaclass ifFalse: [self recompile: aClass class]
-!
-
-recompileAll
-	Smalltalk current classes do: [:each |
-		self recompile: each]
-! !
-
-SequenceNode subclass: #BlockSequenceNode
-	instanceVariableNames: ''
-	category: 'Compiler'!
-
-!BlockSequenceNode methodsFor: 'testing'!
-
-isBlockSequenceNode
-	^true
-! !
-
-!BlockSequenceNode methodsFor: 'visiting'!
-
-accept: aVisitor
-	aVisitor visitBlockSequenceNode: self
-! !
-
-Node subclass: #BlockNode
-	instanceVariableNames: 'parameters inlined'
-	category: 'Compiler'!
-
-!BlockNode methodsFor: 'accessing'!
-
-parameters
-	^parameters ifNil: [parameters := Array new]
-!
-
-parameters: aCollection
-	parameters := aCollection
-!
-
-inlined
-	^inlined ifNil: [false]
-!
-
-inlined: aBoolean
-	inlined := aBoolean
-! !
-
-!BlockNode methodsFor: 'testing'!
-
-isBlockNode
-	^true
-! !
-
-!BlockNode methodsFor: 'visiting'!
-
-accept: aVisitor
-	aVisitor visitBlockNode: self
-! !
-
-Node subclass: #CascadeNode
-	instanceVariableNames: 'receiver'
-	category: 'Compiler'!
-
-!CascadeNode methodsFor: 'accessing'!
-
-receiver
-	^receiver
-!
-
-receiver: aNode
-	receiver := aNode
-! !
-
-!CascadeNode methodsFor: 'visiting'!
-
-accept: aVisitor
-	aVisitor visitCascadeNode: self
-! !
-
-Node subclass: #MethodNode
-	instanceVariableNames: 'selector arguments source'
-	category: 'Compiler'!
-
-!MethodNode methodsFor: 'accessing'!
-
-selector
-	^selector
-!
-
-selector: aString
-	selector := aString
-!
-
-arguments
-	^arguments ifNil: [#()]
-!
-
-arguments: aCollection
-	arguments := aCollection
-!
-
-source
-	^source
-!
-
-source: aString
-	source := aString
-! !
-
-!MethodNode methodsFor: 'visiting'!
-
-accept: aVisitor
-	aVisitor visitMethodNode: self
-! !
-
-Exporter subclass: #StrippedExporter
-	instanceVariableNames: ''
-	category: 'Compiler'!
-
-!StrippedExporter methodsFor: 'private'!
-
-exportDefinitionOf: aClass on: aStream
-	aStream 
-	    nextPutAll: 'smalltalk.addClass(';
-	    nextPutAll: '''', (self classNameFor: aClass), ''', ';
-	    nextPutAll: 'smalltalk.', (self classNameFor: aClass superclass);
-	    nextPutAll: ', ['.
-	aClass instanceVariableNames 
-	    do: [:each | aStream nextPutAll: '''', each, '''']
-	    separatedBy: [aStream nextPutAll: ', '].
-	aStream	
-	    nextPutAll: '], ''';
-	    nextPutAll: aClass category, '''';
-	    nextPutAll: ');'.
-	aStream lf
-!
-
-exportMethod: aMethod of: aClass on: aStream
-	aStream 
-		nextPutAll: 'smalltalk.addMethod(';lf;
-		nextPutAll: 'unescape(''', aMethod selector asSelector escaped, '''),';lf;
-		nextPutAll: 'smalltalk.method({';lf;
-		nextPutAll: 'selector: unescape(''', aMethod selector escaped, '''),';lf;
-		nextPutAll: 'fn: ', aMethod fn compiledSource;lf;
-		nextPutAll: '}),';lf;
-		nextPutAll: 'smalltalk.', (self classNameFor: aClass);
-		nextPutAll: ');';lf;lf
-! !
-