resin 0.2.2 → 0.2.3

data/amber/st/Compiler-Tests.st

@@ -1,471 +1,375 @@
 Smalltalk current createPackage: 'Compiler-Tests' properties: #{}!
-TestCase subclass: #ImporterTest
-	instanceVariableNames: ''
-	category: 'Compiler-Tests'!
-
-!ImporterTest methodsFor: 'private'!
-
-chunkString
-
-	^'!!Object methodsFor: ''importer test method''!!
+TestCase subclass: #CodeGeneratorTest
+	instanceVariableNames: 'receiver'
+	package: 'Compiler-Tests'!
 
-importerTestMethod
+!CodeGeneratorTest methodsFor: 'accessing'!
 
-	^''success''
-!! !!
-'
+codeGeneratorClass
+	^ CodeGenerator
 !
 
-bigChunkString
-
-	^'Smalltalk current createPackage: ''Cypress-Definitions'' properties: #{}!!
-Object subclass: #CypressSnapshot
-	instanceVariableNames: ''definitions''
-	package: ''Cypress-Definitions''!!
-
-!!CypressSnapshot methodsFor: ''not yet classified''!!
-
-definitions: aDefinitions
-
-	definitions := aDefinitions
-!!
-
-definitions
-
-	^definitions
-!! !!
-
-!!CypressSnapshot class methodsFor: ''not yet classified''!!
-
-definitions: aDefinitions
-
-	^(self new) definitions: aDefinitions
-!! !!
-
-Object subclass: #CypressPackage
-	instanceVariableNames: ''name''
-	package: ''Cypress-Definitions''!!
-
-!!CypressPackage methodsFor: ''not yet classified''!!
-
-= other
-	^ other species = self species and: [other name sameAs: name]
-!!
+targetClass
+	^ DoIt
+! !
 
-name
-	^ name
-!!
+!CodeGeneratorTest methodsFor: 'factory'!
 
-name: aString
-	name := aString
-!!
+compiler
+	^ Compiler new
+		codeGeneratorClass: self codeGeneratorClass;
+		yourself
+! !
 
-snapshot
-	| package definitions name  |
-	package := Package named: self name.
-	definitions := OrderedCollection new.
-	package sortedClasses do: [:cls |
-        	definitions add: cls asCypressClassDefinition.
-                cls methodDictionary values do: [:method |
-			(method category match: ''^\*'') ifFalse: [ 
-				definitions add: method asCypressMethodDefinition ]].
-                cls class methodDictionary values do: [:method |
-			(method category match: ''^\*'') ifFalse: [ 
-				definitions add: method asCypressMethodDefinition ]]].
-	name := package name.
-	Smalltalk current classes, (Smalltalk current classes collect: [:each | each class]) do: [:each |
-		each methodDictionary values do: [:method |
-			method category = (''*'', name) ifTrue: [
-				definitions add: method asCypressMethodDefinition ]]].
-	^ CypressSnapshot definitions: definitions
-!!
+!CodeGeneratorTest methodsFor: 'initialization'!
 
-printString
-	^super printString, ''('', name, '')''
-!! !!
+setUp
+	receiver := self targetClass new
+!
 
-Object subclass: #CypressDefinition
-	instanceVariableNames: ''''
-	package: ''Cypress-Definitions''!!
+tearDown
+	"receiver := nil"
+! !
 
-!!CypressDefinition methodsFor: ''not yet classified''!!
+!CodeGeneratorTest methodsFor: 'testing'!
 
-= aDefinition
-	^(aDefinition isKindOf: CypressDefinition) and: [self isRevisionOf: aDefinition]
-!!
+should: aString return: anObject
+	| method result |
 
-isRevisionOf: aDefinition
-	^ (aDefinition isKindOf: CypressDefinition) and: [aDefinition description = self description]
-!!
+	method := self compiler install: aString forClass: self targetClass category: 'tests'.
+	result := receiver perform: method selector.
+	self targetClass removeCompiledMethod: method.
+	self assert: anObject equals: result
+! !
 
-description
-	self subclassResponsibility
-!!
+!CodeGeneratorTest methodsFor: 'tests'!
 
-isSameRevisionAs: aDefinition
-	^ self = aDefinition
-!! !!
+testAssignment
+	self should: 'foo | a | a := true ifTrue: [ 1 ]. ^ a' return: 1.
+	self should: 'foo | a | a := false ifTrue: [ 1 ]. ^ a' return: nil.
 
-Object subclass: #CypressPatch
-	instanceVariableNames: ''operations''
-	package: ''Cypress-Definitions''!!
+	self should: 'foo | a | ^ a := true ifTrue: [ 1 ]' return: 1
+!
 
-!!CypressPatch methodsFor: ''not yet classified''!!
+testBlockReturn
+	self should: 'foo ^ #(1 2 3) collect: [ :each | true ifTrue: [ each + 1 ] ]' return: #(2 3 4).
+	self should: 'foo ^ #(1 2 3) collect: [ :each | false ifFalse: [ each + 1 ] ]' return: #(2 3 4).
+	self should: 'foo ^ #(1 2 3) collect: [ :each | each odd ifTrue: [ each + 1 ] ifFalse: [ each - 1 ] ]' return: #(2 1 4).
+!
 
-fromBase: baseSnapshot toTarget: targetSnapshot
-	| base target |	
-	operations := OrderedCollection new.
-	base := CypressDefinitionIndex definitions: baseSnapshot definitions.
-	target := CypressDefinitionIndex definitions: targetSnapshot definitions.
+testCascades
 	
-	target definitions do:
-		[:t |
-		base
-			definitionLike: t
-			ifPresent: [:b | (b isSameRevisionAs: t) ifFalse: [operations add: (CypressModification of: b to: t)]]
-			ifAbsent: [operations add: (CypressAddition of: t)]].
-		
-	base definitions do:
-		[:b |
-		target
-			definitionLike: b
-			ifPresent: [:t | ]
-			ifAbsent: [operations add: (CypressRemoval of: b)]]
-!!
-
-operations
-
-	^operations
-!! !!
-
-!!CypressPatch class methodsFor: ''not yet classified''!!
-
-fromBase: baseSnapshot toTarget: targetSnapshot
-	^ (self new)
-		fromBase: baseSnapshot
-		toTarget: targetSnapshot
-!! !!
-
-Object subclass: #CypressDefinitionIndex
-	instanceVariableNames: ''definitionMap''
-	package: ''Cypress-Definitions''!!
-
-!!CypressDefinitionIndex methodsFor: ''not yet classified''!!
-
-add: aDefinition
-	^ self definitionMap at: aDefinition description put: aDefinition
-!!
-
-addAll: aCollection
-	aCollection do: [:ea | self add: ea]
-!!
-
-definitionLike: aDefinition ifPresent: foundBlock ifAbsent: errorBlock
-	| definition |
-	definition := self definitionMap at: aDefinition description ifAbsent: [].
-	^ definition
-		ifNil: errorBlock
-		ifNotNil: [foundBlock value: definition]
-!!
-
-definitions
-	^self definitionMap values
-!!
-
-definitionMap
-	definitionMap ifNil: [ definitionMap := Dictionary new ].
-	^ definitionMap
-!!
-
-remove: aDefinition
-	self definitionMap removeKey: aDefinition description ifAbsent: []
-!! !!
-
-!!CypressDefinitionIndex class methodsFor: ''not yet classified''!!
-
-definitions: aCollection
-	^ self new addAll: aCollection
-!! !!
-
-Object subclass: #CypressPatchOperation
-	instanceVariableNames: ''''
-	package: ''Cypress-Definitions''!!
-
-CypressDefinition subclass: #CypressClassDefinition
-	instanceVariableNames: ''name superclassName category comment instVarNames classInstVarNames''
-	package: ''Cypress-Definitions''!!
-
-!!CypressClassDefinition methodsFor: ''not yet classified''!!
-
-name: aClassName superclassName: aSuperclassName category: aCategory instVarNames: anInstanceVariableNames classInstVarNames: aClassInstanceVariableNames comment: aComment
-
-	name := aClassName.
-	superclassName := aSuperclassName.
-	category := aCategory.
-	instVarNames := anInstanceVariableNames.
-	classInstVarNames := aClassInstanceVariableNames.
-	comment := aComment
-!!
-
-= aDefinition
-	^(super = aDefinition)
-		and: [superclassName = aDefinition superclassName
-		and: [category = aDefinition category
-		and: [instVarNames = aDefinition instVarNames
-		and: [classInstVarNames = aDefinition classInstVarNames
-		and: [comment = aDefinition comment]]]]]
-!!
-
-superclassName
-
-	^superclassName
-!!
-
-name
-
-	^name
-!!
-
-category
-
-	^category
-!!
-
-comment
-
-	^comment
-!!
+	self should: 'foo ^ Array new add: 3; add: 4; yourself' return: #(3 4)
+!
 
-description
+testLiterals
+	self should: 'foo ^ 1' return: 1.
+	self should: 'foo ^ ''hello''' return: 'hello'.
+	self should: 'foo ^ #(1 2 3 4)' return: #(1 2 3 4).
+	self should: 'foo ^ {1. [:x | x ] value: 2. 3. [4] value}' return: #(1 2 3 4).
+	self should: 'foo ^ true' return: true.
+	self should: 'foo ^ false' return: false.
+	self should: 'foo ^ #{1->2. 3->4}' return: #{1->2. 3->4}.
+	self should: 'foo ^ #hello' return: #hello.
+	self should: 'foo ^ -123.456' return: -123.456
+!
 
-	^ Array with: name
-!!
+testLocalReturn
+	self should: 'foo ^ 1' return: 1.
+	self should: 'foo ^ 1 + 1' return: 2.
+	self should: 'foo ' return: receiver.
+	self should: 'foo self asString' return: receiver.
+	self should: 'foo | a b | a := 1. b := 2. ^ a + b' return: 3
+!
 
-instVarNames
+testMessageSends
+	self should: 'foo ^ 1 asString' return: '1'.
 
-	^instVarNames
-!!
+	self should: 'foo ^ 1 + 1' return: 2.
+	self should: 'foo ^ 1 + 2 * 3' return: 9.
 
-classInstVarNames
+	self should: 'foo ^ 1 to: 3' return: #(1 2 3).
+	self should: 'foo ^ 1 to: 5 by: 2' return: #(1 3 5)
+!
 
-	^classInstVarNames
-!! !!
+testNestedIfTrue
+	self should: 'foo ^ true ifTrue: [ false ifFalse: [ 1 ] ]' return: 1.
+	self should: 'foo ^ true ifTrue: [ false ifTrue: [ 1 ] ]' return: nil.
 
-!!CypressClassDefinition class methodsFor: ''not yet classified''!!
+	self should: 'foo true ifTrue: [ false ifFalse: [ ^ 1 ] ]' return: 1.
+	self should: 'foo true ifTrue: [ false ifTrue: [ ^ 1 ] ]' return: receiver.
+!
 
-name: aClassName 
-superclassName: aSuperclassName
-category: aCategory
-instVarNames: anInstanceVariableNames
-classInstVarNames: aClassInstanceVariableNames
-comment: aComment
+testNonLocalReturn
+	self should: 'foo [ ^ 1 ] value' return: 1.
+	self should: 'foo [ ^ 1 + 1 ] value' return: 2.
+	self should: 'foo | a b | a := 1. b := 2. [ ^ a + b ] value. self halt' return: 3.
+	self should: 'foo [ :x | ^ x + x ] value: 4. ^ 2' return: 8
+!
 
-	^(self new) 
-		name: aClassName 
-		superclassName: aSuperclassName
-		category: aCategory
-		instVarNames: anInstanceVariableNames
-		classInstVarNames: aClassInstanceVariableNames
-		comment: aComment
-!! !!
+testifFalse
+	self should: 'foo true ifFalse: [ ^ 1 ]' return: receiver.
+	self should: 'foo false ifFalse: [ ^ 2 ]' return: 2.
+	
+	self should: 'foo ^ true ifFalse: [ 1 ]' return: nil.
+	self should: 'foo ^ false ifFalse: [ 2 ]' return: 2.
+!
 
-CypressDefinition subclass: #CypressMethodDefinition
-	instanceVariableNames: ''classIsMeta source category selector className''
-	package: ''Cypress-Definitions''!!
+testifFalseIfTrue
+	self should: 'foo true ifFalse: [ ^ 1 ] ifTrue: [ ^ 2 ]' return: 2.
+	self should: 'foo false ifFalse: [ ^ 2 ] ifTrue: [ ^1 ]' return: 2.
+	
+	self should: 'foo ^ true ifFalse: [ 1 ] ifTrue: [ 2 ]' return: 2.
+	self should: 'foo ^ false ifFalse: [ 2 ] ifTrue: [ 1 ]' return: 2.
+!
 
-!!CypressMethodDefinition methodsFor: ''not yet classified''!!
+testifNil
+	self should: 'foo ^ 1 ifNil: [ 2 ]' return: 1.
+	self should: 'foo ^ nil ifNil: [ 2 ]' return: 2.
 
-className: aName classIsMeta: isMetaclass selector: aSelector category: aCategory source: aSource
+	self should: 'foo 1 ifNil: [ ^ 2 ]' return: receiver.
+	self should: 'foo nil ifNil: [ ^ 2 ]' return: 2.
+!
 
-	className := aName.
-	classIsMeta := isMetaclass.
-	selector := aSelector.
-	category := aCategory.
-	source := aSource.
-!!
+testifNilIfNotNil
+	self should: 'foo ^ 1 ifNil: [ 2 ] ifNotNil: [ 3 ]' return: 3.
+	self should: 'foo ^ nil ifNil: [ 2 ] ifNotNil: [ 3 ]' return: 2.
 
-= aDefinition
-    ^ super = aDefinition
-        and: [ aDefinition source = self source
-                and: [ aDefinition category = self category ] ]
-!!
+	self should: 'foo 1 ifNil: [ ^ 2 ] ifNotNil: [ ^3 ]' return: 3.
+	self should: 'foo nil ifNil: [ ^ 2 ] ifNotNil: [ ^3 ]' return: 2.
+!
 
-source
+testifNotNil
+	self should: 'foo ^ 1 ifNotNil: [ 2 ]' return: 2.
+	self should: 'foo ^ nil ifNotNil: [ 2 ]' return: nil.
 
-	^source
-!!
+	self should: 'foo 1 ifNotNil: [ ^ 2 ]' return: 2.
+	self should: 'foo nil ifNotNil: [ ^ 2 ]' return: receiver.
+!
 
-category
+testifTrue
+	self should: 'foo false ifTrue: [ ^ 1 ]' return: receiver.
+	self should: 'foo true ifTrue: [ ^ 2 ]' return: 2.
+	
+	self should: 'foo ^ false ifTrue: [ 1 ]' return: nil.
+	self should: 'foo ^ true ifTrue: [ 2 ]' return: 2.
+!
 
-	^category
-!!
+testifTrueIfFalse
+	self should: 'foo false ifTrue: [ ^ 1 ] ifFalse: [ ^2 ]' return: 2.
+	self should: 'foo true ifTrue: [ ^ 1 ] ifFalse: [ ^ 2 ]' return: 1.
+	
+	self should: 'foo ^ false ifTrue: [ 2 ] ifFalse: [ 1 ]' return: 1.
+	self should: 'foo ^ true ifTrue: [ 2 ] ifFalse: [ 1 ]' return: 2.
+! !
 
-description
-	^ Array	
-		with: className
-		with: selector
-		with: classIsMeta
-!! !!
+CodeGeneratorTest subclass: #InliningCodeGeneratorTest
+	instanceVariableNames: ''
+	package: 'Compiler-Tests'!
 
-!!CypressMethodDefinition class methodsFor: ''not yet classified''!!
+!InliningCodeGeneratorTest methodsFor: 'accessing'!
 
-className: aName
-classIsMeta: isMetaclass
-selector: aSelector
-category: aCategory
-source: aSource
+codeGeneratorClass
+	^ InliningCodeGenerator
+! !
 
-	^(self new)
-		className: aName
-		classIsMeta: isMetaclass
-		selector: aSelector
-		category: aCategory
-		source: aSource
-!! !!
+TestCase subclass: #ScopeVarTest
+	instanceVariableNames: ''
+	package: 'Compiler-Tests'!
 
-CypressPatchOperation subclass: #CypressAddition
-	instanceVariableNames: ''definition''
-	package: ''Cypress-Definitions''!!
+!ScopeVarTest methodsFor: 'tests'!
 
-!!CypressAddition methodsFor: ''not yet classified''!!
+testClassRefVar
+	| node |
+	node := ClassReferenceNode new
+		value: 'Object';
+		yourself.
+	SemanticAnalyzer new visit: node.
+	self assert: node binding isClassRefVar
+!
 
-definition: aDefinition
+testInstanceVar
+	| node scope |
+	node := VariableNode new
+		value: 'bzzz';
+		yourself.
+	scope := MethodLexicalScope new.
+	scope addIVar: 'bzzz'.
+	self assert: (scope bindingFor: node) isInstanceVar
+!
 
-	definition := aDefinition
-!! !!
+testPseudoVar
+	| node pseudoVars |
+	pseudoVars := #('self' 'super' 'true' 'false' 'nil').
+	pseudoVars do: [:each |
+		node := VariableNode new
+		value: each;
+		yourself.
+		self assert: (MethodLexicalScope new bindingFor: node) isPseudoVar ]
+!
 
-!!CypressAddition class methodsFor: ''not yet classified''!!
+testTempVar
+	| node scope |
+	node := VariableNode new
+		value: 'bzzz';
+		yourself.
+	scope := MethodLexicalScope new.
+	scope addTemp: 'bzzz'.
+	self assert: (scope bindingFor: node) isTempVar
+!
 
-of: aDefinition
-	^ self new definition: aDefinition
-!! !!
+testUnknownVar
+	| node |
+	node := VariableNode new
+		value: 'bzzz';
+		yourself.
+	self assert: (MethodLexicalScope new bindingFor: node) isNil
+! !
 
-CypressPatchOperation subclass: #CypressModification
-	instanceVariableNames: ''obsoletion modification''
-	package: ''Cypress-Definitions''!!
+TestCase subclass: #SemanticAnalyzerTest
+	instanceVariableNames: 'analyzer'
+	package: 'Compiler-Tests'!
 
-!!CypressModification methodsFor: ''not yet classified''!!
+!SemanticAnalyzerTest methodsFor: 'running'!
 
-base: base target: target
+setUp
+	analyzer := SemanticAnalyzer on: Object
+! !
 
-	obsoletion := base.
-	modification := target.
-!! !!
+!SemanticAnalyzerTest methodsFor: 'tests'!
 
-!!CypressModification class methodsFor: ''not yet classified''!!
+testAssignment
+	| src ast |
 
-of: base to: target
-	^ self new base: base target: target
-!! !!
+	src := 'foo self := 1'.
+	ast := smalltalk parse: src.
+	self should: [analyzer visit: ast] raise: InvalidAssignmentError
+!
 
-CypressPatchOperation subclass: #CypressRemoval
-	instanceVariableNames: ''definition''
-	package: ''Cypress-Definitions''!!
+testNonLocalReturn
+	| src ast |
 
-!!CypressRemoval methodsFor: ''not yet classified''!!
+	src := 'foo | a | a + 1. ^ a'.
+	ast := smalltalk parse: src.
+	analyzer visit: ast.
 
-definition: aDefinition
+	self deny: ast scope hasNonLocalReturn
+!
 
-	definition := aDefinition
-!! !!
+testNonLocalReturn2
+	| src ast |
 
-!!CypressRemoval class methodsFor: ''not yet classified''!!
+	src := 'foo | a | a + 1. [ [ ^ a] ]'.
+	ast := smalltalk parse: src.
+	analyzer visit: ast.
 
-of: aDefinition
-	^ self new definition: aDefinition
-!! !!
+	self assert: ast scope hasNonLocalReturn
+!
 
-!!Object methodsFor: ''*Cypress-Definitions''!!
+testScope
+	| src ast |
 
-species
+	src := 'foo | a | a + 1. [ | b | b := a ]'.
+	ast := smalltalk parse: src.
+	analyzer visit: ast.
 
-	^self class
-!! !!
+	self deny: ast nodes first nodes last scope == ast scope.
+!
 
-!!Class methodsFor: ''*Cypress-Definitions''!!
+testScope2
+	| src ast |
 
-asCypressClassDefinition
-	^CypressClassDefinition
-		name: self name
-		superclassName: self superclass name
-		category: self category 
-		instVarNames: self instanceVariableNames
-		classInstVarNames: self class instanceVariableNames
-		comment: self comment
-!! !!
+	src := 'foo | a | a + 1. [ [ | b | b := a ] ]'.
+	ast := smalltalk parse: src.
+	analyzer visit: ast.
 
-!!CompiledMethod methodsFor: ''*Cypress-Definitions''!!
+	self deny: ast nodes first nodes last nodes first nodes first scope == ast scope.
+!
 
-asCypressMethodDefinition
+testScopeLevel
+	| src ast |
 
-	^CypressMethodDefinition 
-        	className: self methodClass name
-		classIsMeta: self methodClass isMetaclass
-		selector: self selector
-		category: self category
-		source: self source
-!! !!
+	src := 'foo | a | a + 1. [ [ | b | b := a ] ]'.
+	ast := smalltalk parse: src.
+	analyzer visit: ast.
 
-!!CharacterArray methodsFor: ''*Cypress-Definitions''!!
+	self assert: ast scope scopeLevel = 1.
+	self assert: ast nodes first nodes last nodes first nodes first scope scopeLevel = 3
+!
 
-sameAs: aString
+testUnknownVariables
+	| src ast |
 
-	^self asUppercase = aString asUppercase
-!! !!
+	src := 'foo | a | b + a'.
+	ast := smalltalk parse: src.
 
-'
-! !
+	self should: [ analyzer visit: ast ] raise: UnknownVariableError
+!
 
-!ImporterTest methodsFor: 'running'!
+testUnknownVariablesDefinedInJS
 
-setUp
+	< var someVariable = 1 >.
 
-	super setUp.
-	self cleanUp
+	self shouldnt: [ smalltalk parse: 'foo someVariable' ] raise: UnknownVariableError
 !
 
-tearDown
+testUnknownVariablesWithScope
+	| src ast |
 
-	super tearDown.
-	self cleanUp
+	src := 'foo | a b | [ c + 1. [ a + 1. d + 1 ]]'.
+	ast := smalltalk parse: src.
+	
+	self should: [ analyzer visit: ast ] raise: UnknownVariableError
 !
 
-cleanUp
-
-	(Object methodDictionary includesKey: #importerTestMethod)
-		ifTrue: [ Object removeCompiledMethod: (Object methodAt: #importerTestMethod)].
-! !
-
-!ImporterTest methodsFor: 'tests'!
-
-testBigChunkString
-	"importer does not correctly add extension methods.
-
-	 After loading in AmberProjectImporter, the following import fails...get a MNU from `CypressPackage new species`:
-
-    		AmberProjectImporter
-			importSTPackage: 'Cypress-Definitions' 
-			prefix: 'tests/'.
+testVariableShadowing
+	| src ast |
+	src := 'foo | a | a + 1'.
+	ast := smalltalk parse: src.
+	analyzer visit: ast
+!
 
-		CypressPackage new species. 
+testVariableShadowing2
+	| src ast |
+	src := 'foo | a | a + 1. [ | a | a := 2 ]'.
+	ast := smalltalk parse: src.
+	self should: [analyzer visit: ast] raise: ShadowingVariableError
+!
 
-	WARNING this guy isn't cleaned up automatically"
+testVariableShadowing3
+	| src ast |
+	src := 'foo | a | a + 1. [ | b | b := 2 ]'.
+	ast := smalltalk parse: src.
+	analyzer visit: ast
+!
 
-	Importer new import: self bigChunkString readStream.
-	CypressPackage new species.
+testVariableShadowing4
+	| src ast |
+	src := 'foo | a | a + 1. [ [ [ | b | b := 2 ] ] ]'.
+	ast := smalltalk parse: src.
+	analyzer visit: ast
 !
 
-testChunkString
+testVariableShadowing5
+	| src ast |
+	src := 'foo | a | a + 1. [ [ [ | a | a := 2 ] ] ]'.
+	ast := smalltalk parse: src.
+	self should: [analyzer visit: ast] raise: ShadowingVariableError
+!
 
-	Importer new import: self chunkString readStream.
-	self assert: (Object methodDictionary includesKey: 'importerTestMethod').
-	self assert: (Object new importerTestMethod = 'success').
-! !
+testVariablesLookup
+	| src ast |
 
-!Object methodsFor: '*Compiler-Tests'!
+	src := 'foo | a | a + 1. [ | b | b := a ]'.
+	ast := smalltalk parse: src.
+	analyzer visit: ast.
 
-importerLoadMethod
+	"Binding for `a` in the message send"
+	self assert: ast nodes first nodes first receiver binding isTempVar.
+	self assert: ast nodes first nodes first receiver binding scope == ast scope.
 
-	^'success'
+	"Binding for `b`"
+	self assert: ast nodes first nodes last nodes first nodes first left binding isTempVar.
+	self assert: ast nodes first nodes last nodes first nodes first left binding scope == ast nodes first nodes last scope.
 ! !