resin 0.0.1 → 0.0.2

data/amber/st/Compiler.st

@@ -1,45 +1,81 @@
 Smalltalk current createPackage: 'Compiler' properties: #{}!
-Object subclass: #ChunkParser
-	instanceVariableNames: 'stream'
+Object subclass: #NodeVisitor
+	instanceVariableNames: ''
 	category: 'Compiler'!
 
-!ChunkParser methodsFor: 'accessing'!
+!NodeVisitor methodsFor: 'visiting'!
 
-stream: aStream
-	stream := aStream
-! !
+visit: aNode
+	aNode accept: self
+!
 
-!ChunkParser methodsFor: 'reading'!
+visitNode: aNode
+!
 
-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.
+visitMethodNode: aNode
+	self visitNode: aNode
+!
 
-	This metod returns next chunk as a String (trimmed), empty String (all whitespace) or nil."
+visitSequenceNode: aNode
+	self visitNode: aNode
+!
 
-	| 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 !!"
-! !
+visitBlockSequenceNode: aNode
+	self visitSequenceNode: aNode
+!
 
-!ChunkParser class methodsFor: 'not yet classified'!
+visitBlockNode: aNode
+	self visitNode: aNode
+!
 
-on: aStream
-	^self new stream: aStream
+visitReturnNode: aNode
+	self visitNode: aNode
+!
+
+visitSendNode: aNode
+	self visitNode: aNode
+!
+
+visitCascadeNode: aNode
+	self visitNode: aNode
+!
+
+visitValueNode: aNode
+	self visitNode: aNode
+!
+
+visitVariableNode: aNode
+!
+
+visitAssignmentNode: aNode
+	self visitNode: aNode
+!
+
+visitClassReferenceNode: aNode
+	self 
+	    nextPutAll: 'smalltalk.';
+	    nextPutAll: aNode value
+!
+
+visitJSStatementNode: aNode
+	self 
+	    nextPutAll: 'function(){';
+	    nextPutAll: aNode source;
+	    nextPutAll: '})()'
+!
+
+visitDynamicArrayNode: aNode
+	self visitNode: aNode
+!
+
+visitDynamicDictionaryNode: aNode
+	self visitNode: aNode
 ! !
 
+Object subclass: #DoIt
+	instanceVariableNames: ''
+	category: 'Compiler'!
+
 Object subclass: #Importer
 	instanceVariableNames: ''
 	category: 'Compiler'!
@@ -75,7 +111,8 @@ exportPackage: packageName
 	^String streamContents: [:stream |
                 package := Smalltalk current packageAt: packageName.
                 self exportPackageDefinitionOf: package on: stream.
-	    	package classes do: [:each |
+		"Export classes in dependency order"
+	    	package sortedClasses do: [:each |
                         stream nextPutAll: (self exportClass: each)].
 		self exportPackageExtensionsOf: package on: stream]
 !
@@ -185,140 +222,45 @@ exportPackageDefinitionOf: package on: aStream
 	aStream lf
 ! !
 
-Exporter subclass: #ChunkExporter
-	instanceVariableNames: ''
+Object subclass: #ChunkParser
+	instanceVariableNames: 'stream'
 	category: 'Compiler'!
 
-!ChunkExporter methodsFor: 'not yet classified'!
-
-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: '	category: ''', aClass category, '''!!'; lf.
- 	aClass comment notEmpty ifTrue: [
-	    aStream 
-		nextPutAll: '!!', (self classNameFor: aClass), ' commentStamp!!';lf;
-		nextPutAll: (self chunkEscape: aClass comment), '!!';lf].
-	aStream lf
-!
-
-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]]
-!
-
-chunkEscape: aString
-	"Replace all occurrences of !! with !!!! and trim at both ends."
-
-	^(aString replace: '!!' with: '!!!!') trimBoth
-!
-
-exportMethods: methods category: category of: aClass on: aStream
+!ChunkParser methodsFor: 'accessing'!
 
-	aStream
-		nextPutAll: '!!', (self classNameFor: aClass);
-		nextPutAll: ' methodsFor: ''', category, '''!!'.
-    	methods do: [:each |
-		self exportMethod: each of: aClass on: aStream].
-	aStream nextPutAll: ' !!'; lf; lf
-!
+stream: aStream
+	stream := aStream
+! !
 
-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."
+!ChunkParser methodsFor: 'reading'!
 
-	| 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]]]
-!
+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.
 
-exportPackageDefinitionOf: package on: aStream
-	"Chunk format."
+	This metod returns next chunk as a String (trimmed), empty String (all whitespace) or nil."
 
-	aStream 
-	    nextPutAll: 'Smalltalk current createPackage: ''', package name,
-		''' properties: ', package properties storeString, '!!'; lf.
+	| 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 !!"
 ! !
 
-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
-!
+!ChunkParser class methodsFor: 'not yet classified'!
 
-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
+on: aStream
+	^self new stream: aStream
 ! !
 
 Object subclass: #Node
@@ -361,292 +303,269 @@ accept: aVisitor
 	aVisitor visitNode: self
 ! !
 
-Node subclass: #MethodNode
-	instanceVariableNames: 'selector arguments source'
+Node subclass: #SequenceNode
+	instanceVariableNames: 'temps'
 	category: 'Compiler'!
 
-!MethodNode methodsFor: 'accessing'!
+!SequenceNode methodsFor: 'accessing'!
 
-selector
-	^selector
-!
-
-selector: aString
-	selector := aString
-!
-
-arguments
-	^arguments ifNil: [#()]
+temps
+	^temps ifNil: [#()]
 !
 
-arguments: aCollection
-	arguments := aCollection
-!
+temps: aCollection
+	temps := aCollection
+! !
 
-source
-	^source
-!
+!SequenceNode methodsFor: 'testing'!
 
-source: aString
-	source := aString
+asBlockSequenceNode
+	^BlockSequenceNode new
+	    nodes: self nodes;
+	    temps: self temps;
+	    yourself
 ! !
 
-!MethodNode methodsFor: 'visiting'!
+!SequenceNode methodsFor: 'visiting'!
 
 accept: aVisitor
-	aVisitor visitMethodNode: self
+	aVisitor visitSequenceNode: self
 ! !
 
-Node subclass: #SendNode
-	instanceVariableNames: 'selector arguments receiver'
+Node subclass: #DynamicDictionaryNode
+	instanceVariableNames: ''
 	category: 'Compiler'!
 
-!SendNode methodsFor: 'accessing'!
-
-selector
-	^selector
-!
-
-selector: aString
-	selector := aString
-!
-
-arguments
-	^arguments ifNil: [arguments := #()]
-!
-
-arguments: aCollection
-	arguments := aCollection
-!
-
-receiver
-	^receiver
-!
-
-receiver: aNode
-	receiver := aNode
-!
-
-valueForReceiver: anObject
-	^SendNode new
-	    receiver: (self receiver 
-		ifNil: [anObject]
-		ifNotNil: [self receiver valueForReceiver: anObject]);
-	    selector: self selector;
-	    arguments: self arguments;
-	    yourself
-!
+!DynamicDictionaryNode methodsFor: 'visiting'!
 
-cascadeNodeWithMessages: aCollection
-	| first |
-	first := SendNode new
-	    selector: self selector;
-	    arguments: self arguments;
-	    yourself.
-	^CascadeNode new
-	    receiver: self receiver;
-	    nodes: (Array with: first), aCollection;
-	    yourself
+accept: aVisitor
+	aVisitor visitDynamicDictionaryNode: self
 ! !
 
-!SendNode methodsFor: 'visiting'!
+Node subclass: #ReturnNode
+	instanceVariableNames: ''
+	category: 'Compiler'!
+
+!ReturnNode methodsFor: 'visiting'!
 
 accept: aVisitor
-	aVisitor visitSendNode: self
+	aVisitor visitReturnNode: self
 ! !
 
-Node subclass: #CascadeNode
-	instanceVariableNames: 'receiver'
+Node subclass: #ValueNode
+	instanceVariableNames: 'value'
 	category: 'Compiler'!
 
-!CascadeNode methodsFor: 'accessing'!
+!ValueNode methodsFor: 'accessing'!
 
-receiver
-	^receiver
+value
+	^value
 !
 
-receiver: aNode
-	receiver := aNode
+value: anObject
+	value := anObject
 ! !
 
-!CascadeNode methodsFor: 'visiting'!
+!ValueNode methodsFor: 'testing'!
 
-accept: aVisitor
-	aVisitor visitCascadeNode: self
+isValueNode
+	^true
 ! !
 
-Node subclass: #AssignmentNode
-	instanceVariableNames: 'left right'
-	category: 'Compiler'!
+!ValueNode methodsFor: 'visiting'!
 
-!AssignmentNode methodsFor: 'accessing'!
+accept: aVisitor
+	aVisitor visitValueNode: self
+! !
 
-left
-	^left
-!
+ValueNode subclass: #VariableNode
+	instanceVariableNames: 'assigned'
+	category: 'Compiler'!
 
-left: aNode
-	left := aNode.
-	left assigned: true
-!
+!VariableNode methodsFor: 'accessing'!
 
-right
-	^right
+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: #BlockNode
-	instanceVariableNames: 'parameters inlined'
+Exporter subclass: #ChunkExporter
+	instanceVariableNames: ''
 	category: 'Compiler'!
 
-!BlockNode methodsFor: 'accessing'!
+!ChunkExporter methodsFor: 'not yet classified'!
 
-parameters
-	^parameters ifNil: [parameters := Array new]
-!
+exportDefinitionOf: aClass on: aStream
+	"Chunk format."
 
-parameters: aCollection
-	parameters := aCollection
+	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
 !
 
-inlined
-	^inlined ifNil: [false]
+exportMethod: aMethod of: aClass on: aStream
+	aStream 
+		lf; lf; nextPutAll: (self chunkEscape: aMethod source); lf;
+		nextPutAll: '!!'
 !
 
-inlined: aBoolean
-	inlined := aBoolean
-! !
-
-!BlockNode methodsFor: 'testing'!
-
-isBlockNode
-	^true
-! !
-
-!BlockNode methodsFor: 'visiting'!
-
-accept: aVisitor
-	aVisitor visitBlockNode: self
-! !
+exportMethodsOf: aClass on: aStream
 
-Node subclass: #SequenceNode
-	instanceVariableNames: 'temps'
-	category: 'Compiler'!
+   aClass protocolsDo: [:category :methods |
+	(category match: '^\*') ifFalse: [ 
+		self
+			exportMethods: methods
+			category: category
+			of: aClass
+			on: aStream]]
+!
 
-!SequenceNode methodsFor: 'accessing'!
+exportMetaDefinitionOf: aClass on: aStream
 
-temps
-	^temps ifNil: [#()]
+	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]
 !
 
-temps: aCollection
-	temps := aCollection
-! !
-
-!SequenceNode methodsFor: 'testing'!
+classNameFor: aClass
+	^aClass isMetaclass
+	    ifTrue: [aClass instanceClass name, ' class']
+	    ifFalse: [
+		aClass isNil
+		    ifTrue: ['nil']
+		    ifFalse: [aClass name]]
+!
 
-asBlockSequenceNode
-	^BlockSequenceNode new
-	    nodes: self nodes;
-	    temps: self temps;
-	    yourself
-! !
+chunkEscape: aString
+	"Replace all occurrences of !! with !!!! and trim at both ends."
 
-!SequenceNode methodsFor: 'visiting'!
+	^(aString replace: '!!' with: '!!!!') trimBoth
+!
 
-accept: aVisitor
-	aVisitor visitSequenceNode: self
-! !
+exportMethods: methods category: category of: aClass on: aStream
 
-SequenceNode subclass: #BlockSequenceNode
-	instanceVariableNames: ''
-	category: 'Compiler'!
+	aStream
+		nextPutAll: '!!', (self classNameFor: aClass);
+		nextPutAll: ' methodsFor: ''', category, '''!!'.
+    	methods do: [:each |
+		self exportMethod: each of: aClass on: aStream].
+	aStream nextPutAll: ' !!'; lf; lf
+!
 
-!BlockSequenceNode methodsFor: 'testing'!
+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."
 
-isBlockSequenceNode
-	^true
-! !
+	| 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]]]
+!
 
-!BlockSequenceNode methodsFor: 'visiting'!
+exportPackageDefinitionOf: package on: aStream
+	"Chunk format."
 
-accept: aVisitor
-	aVisitor visitBlockSequenceNode: self
+	aStream 
+	    nextPutAll: 'Smalltalk current createPackage: ''', package name,
+		''' properties: ', package properties storeString, '!!'; lf.
 ! !
 
-Node subclass: #ReturnNode
+VariableNode subclass: #ClassReferenceNode
 	instanceVariableNames: ''
 	category: 'Compiler'!
 
-!ReturnNode methodsFor: 'visiting'!
+!ClassReferenceNode methodsFor: 'visiting'!
 
 accept: aVisitor
-	aVisitor visitReturnNode: self
+	aVisitor visitClassReferenceNode: self
 ! !
 
-Node subclass: #ValueNode
-	instanceVariableNames: 'value'
+Node subclass: #SendNode
+	instanceVariableNames: 'selector arguments receiver'
 	category: 'Compiler'!
 
-!ValueNode methodsFor: 'accessing'!
+!SendNode methodsFor: 'accessing'!
 
-value
-	^value
+selector
+	^selector
 !
 
-value: anObject
-	value := anObject
-! !
-
-!ValueNode methodsFor: 'testing'!
-
-isValueNode
-	^true
-! !
-
-!ValueNode methodsFor: 'visiting'!
-
-accept: aVisitor
-	aVisitor visitValueNode: self
-! !
+selector: aString
+	selector := aString
+!
 
-ValueNode subclass: #VariableNode
-	instanceVariableNames: 'assigned'
-	category: 'Compiler'!
+arguments
+	^arguments ifNil: [arguments := #()]
+!
 
-!VariableNode methodsFor: 'accessing'!
+arguments: aCollection
+	arguments := aCollection
+!
 
-assigned
-	^assigned ifNil: [false]
+receiver
+	^receiver
 !
 
-assigned: aBoolean
-	assigned := aBoolean
-! !
+receiver: aNode
+	receiver := aNode
+!
 
-!VariableNode methodsFor: 'visiting'!
+valueForReceiver: anObject
+	^SendNode new
+	    receiver: (self receiver 
+		ifNil: [anObject]
+		ifNotNil: [self receiver valueForReceiver: anObject]);
+	    selector: self selector;
+	    arguments: self arguments;
+	    yourself
+!
 
-accept: aVisitor
-	aVisitor visitVariableNode: self
+cascadeNodeWithMessages: aCollection
+	| first |
+	first := SendNode new
+	    selector: self selector;
+	    arguments: self arguments;
+	    yourself.
+	^CascadeNode new
+	    receiver: self receiver;
+	    nodes: (Array with: first), aCollection;
+	    yourself
 ! !
 
-VariableNode subclass: #ClassReferenceNode
-	instanceVariableNames: ''
-	category: 'Compiler'!
-
-!ClassReferenceNode methodsFor: 'visiting'!
+!SendNode methodsFor: 'visiting'!
 
 accept: aVisitor
-	aVisitor visitClassReferenceNode: self
+	aVisitor visitSendNode: self
 ! !
 
 Node subclass: #JSStatementNode
@@ -669,77 +588,43 @@ accept: aVisitor
 	aVisitor visitJSStatementNode: self
 ! !
 
-Object subclass: #NodeVisitor
-	instanceVariableNames: ''
+Node subclass: #AssignmentNode
+	instanceVariableNames: 'left right'
 	category: 'Compiler'!
 
-!NodeVisitor methodsFor: 'visiting'!
-
-visit: aNode
-	aNode accept: self
-!
-
-visitNode: aNode
-!
-
-visitMethodNode: aNode
-	self visitNode: aNode
-!
-
-visitSequenceNode: aNode
-	self visitNode: aNode
-!
-
-visitBlockSequenceNode: aNode
-	self visitSequenceNode: aNode
-!
-
-visitBlockNode: aNode
-	self visitNode: aNode
-!
-
-visitReturnNode: aNode
-	self visitNode: aNode
-!
+!AssignmentNode methodsFor: 'accessing'!
 
-visitSendNode: aNode
-	self visitNode: aNode
+left
+	^left
 !
 
-visitCascadeNode: aNode
-	self visitNode: aNode
+left: aNode
+	left := aNode.
+	left assigned: true
 !
 
-visitValueNode: aNode
-	self visitNode: aNode
+right
+	^right
 !
 
-visitVariableNode: aNode
-!
+right: aNode
+	right := aNode
+! !
 
-visitAssignmentNode: aNode
-	self visitNode: aNode
-!
+!AssignmentNode methodsFor: 'visiting'!
 
-visitClassReferenceNode: aNode
-	self 
-	    nextPutAll: 'smalltalk.';
-	    nextPutAll: aNode value
-!
+accept: aVisitor
+	aVisitor visitAssignmentNode: self
+! !
 
-visitJSStatementNode: aNode
-	self 
-	    nextPutAll: 'function(){';
-	    nextPutAll: aNode source;
-	    nextPutAll: '})()'
-!
+Node subclass: #DynamicArrayNode
+	instanceVariableNames: ''
+	category: 'Compiler'!
 
-visitDynamicArrayNode: aNode
-	self visitNode: aNode
-!
+!DynamicArrayNode methodsFor: 'visiting'!
 
-visitDynamicDictionaryNode: aNode
-	self visitNode: aNode
+accept: aVisitor
+	aVisitor visitDynamicArrayNode: self
 ! !
 
 NodeVisitor subclass: #Compiler
@@ -1399,27 +1284,143 @@ recompileAll
 		self recompile: each]
 ! !
 
-Object subclass: #DoIt
+SequenceNode subclass: #BlockSequenceNode
 	instanceVariableNames: ''
 	category: 'Compiler'!
 
-Node subclass: #DynamicArrayNode
-	instanceVariableNames: ''
+!BlockSequenceNode methodsFor: 'testing'!
+
+isBlockSequenceNode
+	^true
+! !
+
+!BlockSequenceNode methodsFor: 'visiting'!
+
+accept: aVisitor
+	aVisitor visitBlockSequenceNode: self
+! !
+
+Node subclass: #BlockNode
+	instanceVariableNames: 'parameters inlined'
 	category: 'Compiler'!
 
-!DynamicArrayNode methodsFor: 'visiting'!
+!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 visitDynamicArrayNode: self
+	aVisitor visitBlockNode: self
 ! !
 
-Node subclass: #DynamicDictionaryNode
-	instanceVariableNames: ''
+Node subclass: #CascadeNode
+	instanceVariableNames: 'receiver'
 	category: 'Compiler'!
 
-!DynamicDictionaryNode methodsFor: 'visiting'!
+!CascadeNode methodsFor: 'accessing'!
+
+receiver
+	^receiver
+!
+
+receiver: aNode
+	receiver := aNode
+! !
+
+!CascadeNode methodsFor: 'visiting'!
 
 accept: aVisitor
-	aVisitor visitDynamicDictionaryNode: self
+	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
 ! !