Fix bug in assert statements.

It can have multiple expression, not just one

Author: jecisc

src/FAST-Python-Model-Generator/FASTPythonMetamodelGenerator.class.st

@@ -358,6 +358,8 @@ FASTPythonMetamodelGenerator >> defineHierarchy [
 	complex --|> literal.
 	complex --|> tNumericalLiteral.
 
+	concatenatedString --|> expression.
+	
 	conditionalExpression --|> expression.
 	conditionalExpression --|> tWithCondition.
 	conditionalExpression --|> tSliceContent.
@@ -536,8 +538,8 @@ FASTPythonMetamodelGenerator >> defineRelations [
 	((attribute property: #attribute) comment: 'The variable been accessed')
 	<>- ((variable property: #attributeOwner) comment: 'The attribute access accessing me (if it''s the case)').
 
-	((assertStatement property: #expression) comment: 'The expression asserted')
-	<>- ((expression property: #assertOwner) comment: 'The assert statement that own the expression (if it''s the case)').
+	((assertStatement property: #expressions) comment: 'The expressions asserted')
+	<>-* ((expression property: #parentAssertStatement) comment: 'The assert statement that own the expression (if it''s the case)').
 
 	(await property: #expression) <>- (expression property: #parentAwait).
 

src/FAST-Python-Model/FASTPyAssertStatement.class.st

@@ -5,7 +5,7 @@
 ### Children
 | Relation | Origin | Opposite | Type | Comment |
 |---|
-| `expression` | `FASTPyAssertStatement` | `assertOwner` | `FASTPyExpression` | The expression asserted|
+| `expressions` | `FASTPyAssertStatement` | `parentAssertStatement` | `FASTPyExpression` | The expressions asserted|
 
 
 
@@ -14,7 +14,7 @@ Class {
 	#name : 'FASTPyAssertStatement',
 	#superclass : 'FASTPyStatement',
 	#instVars : [
-		'#expression => FMOne type: #FASTPyExpression opposite: #assertOwner'
+		'#expressions => FMMany type: #FASTPyExpression opposite: #parentAssertStatement'
 	],
 	#category : 'FAST-Python-Model-Entities',
 	#package : 'FAST-Python-Model',
@@ -30,25 +30,32 @@ FASTPyAssertStatement class >> annotation [
 	^ self
 ]
 
+{ #category : 'adding' }
+FASTPyAssertStatement >> addExpression: anObject [
+	<generated>
+	^ self expressions add: anObject
+]
+
 { #category : 'accessing' }
-FASTPyAssertStatement >> expression [
-	"Relation named: #expression type: #FASTPyExpression opposite: #assertOwner"
+FASTPyAssertStatement >> expressions [
+	"Relation named: #expressions type: #FASTPyExpression opposite: #parentAssertStatement"
 
 	<generated>
-	<FMComment: 'The expression asserted'>
-	^ expression
+	<FMComment: 'The expressions asserted'>
+	<derived>
+	^ expressions
 ]
 
 { #category : 'accessing' }
-FASTPyAssertStatement >> expression: anObject [
+FASTPyAssertStatement >> expressions: anObject [
 
 	<generated>
-	expression := anObject
+	expressions value: anObject
 ]
 
 { #category : 'navigation' }
-FASTPyAssertStatement >> expressionGroup [
+FASTPyAssertStatement >> expressionsGroup [
 	<generated>
-	<navigation: 'Expression'>
-	^ MooseSpecializedGroup with: self expression
+	<navigation: 'Expressions'>
+	^ MooseSpecializedGroup withAll: self expressions asSet
 ]

src/FAST-Python-Model/FASTPyConcatenatedString.class.st

@@ -12,7 +12,7 @@
 "
 Class {
 	#name : 'FASTPyConcatenatedString',
-	#superclass : 'FASTPyEntity',
+	#superclass : 'FASTPyExpression',
 	#instVars : [
 		'#strings => FMMany type: #FASTPyString opposite: #parentConcatenatedString'
 	],
@@ -24,7 +24,7 @@ Class {
 { #category : 'meta' }
 FASTPyConcatenatedString class >> annotation [
 
-	<FMClass: #ConcatenatedString super: #FASTPyEntity>
+	<FMClass: #ConcatenatedString super: #FASTPyExpression>
 	<package: #'FAST-Python-Model'>
 	<generated>
 	^ self

src/FAST-Python-Model/FASTPyExpression.class.st

@@ -6,7 +6,6 @@
 | Relation | Origin | Opposite | Type | Comment |
 |---|
 | `argumentOwner` | `FASTTExpression` | `arguments` | `FASTTWithArguments` | my owner|
-| `assertOwner` | `FASTPyExpression` | `expression` | `FASTPyAssertStatement` | The assert statement that own the expression (if it's the case)|
 | `assignedIn` | `FASTTExpression` | `expression` | `FASTTAssignment` | Optional assignment where this expression is used|
 | `attributeObjectOwner` | `FASTPyExpression` | `object` | `FASTPyAttributeAccess` | My parent if I define the object of an attribute access (if it's the case).|
 | `caller` | `FASTPyExpression` | `callee` | `FASTPyCall` | The call entity calling me (if it's the case)|
@@ -28,6 +27,7 @@
 | `listSplatOwner` | `FASTPyExpression` | `iterable` | `FASTPyListSplat` | List splat unpacking me (if it's the case)|
 | `pairKeyOwner` | `FASTTExpression` | `key` | `FASTPyPair` | |
 | `pairValueOwner` | `FASTTExpression` | `value` | `FASTPyPair` | |
+| `parentAssertStatement` | `FASTPyExpression` | `expressions` | `FASTPyAssertStatement` | The assert statement that own the expression (if it's the case)|
 | `parentAwait` | `FASTPyExpression` | `expression` | `FASTPyAwait` | |
 | `parentComparisonOperator` | `FASTPyExpression` | `operands` | `FASTPyComparisonOperator` | Parent comparison expression of which I am.|
 | `parentConditional` | `FASTTExpression` | `condition` | `FASTTWithCondition` | Optional condition statement/expression where this expression is used|
@@ -58,7 +58,6 @@ Class {
 	#traits : 'FASTTExpression',
 	#classTraits : 'FASTTExpression classTrait',
 	#instVars : [
-		'#assertOwner => FMOne type: #FASTPyAssertStatement opposite: #expression',
 		'#attributeObjectOwner => FMOne type: #FASTPyAttributeAccess opposite: #object',
 		'#caller => FMOne type: #FASTPyCall opposite: #callee',
 		'#collectionInitializer => FMOne type: #FASTPyCollectionInitializer opposite: #initializers',
@@ -76,6 +75,7 @@ Class {
 		'#keywordArgumentOwner => FMOne type: #FASTPyKeywordArgument opposite: #value',
 		'#lambdaOwner => FMOne type: #FASTPyLambda opposite: #expression',
 		'#listSplatOwner => FMOne type: #FASTPyListSplat opposite: #iterable',
+		'#parentAssertStatement => FMOne type: #FASTPyAssertStatement opposite: #expressions',
 		'#parentAwait => FMOne type: #FASTPyAwait opposite: #expression',
 		'#parentComparisonOperator => FMOne type: #FASTPyComparisonOperator opposite: #operands',
 		'#parentInterpolation => FMOne type: #FASTPyInterpolation opposite: #expression',
@@ -99,31 +99,6 @@ FASTPyExpression class >> annotation [
 	^ self
 ]
 
-{ #category : 'accessing' }
-FASTPyExpression >> assertOwner [
-	"Relation named: #assertOwner type: #FASTPyAssertStatement opposite: #expression"
-
-	<generated>
-	<FMComment: 'The assert statement that own the expression (if it''s the case)'>
-	<container>
-	<derived>
-	^ assertOwner
-]
-
-{ #category : 'accessing' }
-FASTPyExpression >> assertOwner: anObject [
-
-	<generated>
-	assertOwner := anObject
-]
-
-{ #category : 'navigation' }
-FASTPyExpression >> assertOwnerGroup [
-	<generated>
-	<navigation: 'AssertOwner'>
-	^ MooseSpecializedGroup with: self assertOwner
-]
-
 { #category : 'accessing' }
 FASTPyExpression >> attributeObjectOwner [
 	"Relation named: #attributeObjectOwner type: #FASTPyAttributeAccess opposite: #object"
@@ -537,6 +512,30 @@ FASTPyExpression >> listSplatOwnerGroup [
 	^ MooseSpecializedGroup with: self listSplatOwner
 ]
 
+{ #category : 'accessing' }
+FASTPyExpression >> parentAssertStatement [
+	"Relation named: #parentAssertStatement type: #FASTPyAssertStatement opposite: #expressions"
+
+	<generated>
+	<FMComment: 'The assert statement that own the expression (if it''s the case)'>
+	<container>
+	^ parentAssertStatement
+]
+
+{ #category : 'accessing' }
+FASTPyExpression >> parentAssertStatement: anObject [
+
+	<generated>
+	parentAssertStatement := anObject
+]
+
+{ #category : 'navigation' }
+FASTPyExpression >> parentAssertStatementGroup [
+	<generated>
+	<navigation: 'ParentAssertStatement'>
+	^ MooseSpecializedGroup with: self parentAssertStatement
+]
+
 { #category : 'accessing' }
 FASTPyExpression >> parentAwait [
 	"Relation named: #parentAwait type: #FASTPyAwait opposite: #expression"

src/FAST-Python-Tools-Tests/FASTPythonImporterTest.class.st

@@ -170,10 +170,10 @@ FASTPythonImporterTest >> testAssertStatement [
 			self assert: self topEntity sourceCode equals: 'assert b != 0'.
 			self assert: (self topEntity isOfType: FASTPyAssertStatement).
 
-			"Testing value of monovalue relation expression"
-			self assert: self topEntity expression isNotNil.
-
-				stack push: self topEntity expression.
+			"Testing value of multivalued relation expressions"
+			self assert: self topEntity expressions size equals: 1.
+			
+				stack push: (stack top expressions at: 1).
 				self assert: self topEntity sourceCode equals: 'b != 0'.
 				self assert: (self topEntity isOfType: FASTPyComparisonOperator).
 
@@ -194,6 +194,58 @@ FASTPythonImporterTest >> testAssertStatement [
 				self assert: self topEntity operators equals: #('!=')
 ]
 
+{ #category : 'tests - statements' }
+FASTPythonImporterTest >> testAssertStatementWithConcatenatedString [
+	<generated>
+	"Generated as regression test by FASTPyImporterTestGenerator>>#generateTestNamed:fromCode:protocol:
+	Regenerate executing: 	self regenerateTest: #testAssertStatementWithConcatenatedString 	"
+
+	self parse: 'assert 0, "Could not find method in self.functions and no "\
+                          "instance installed"'.
+
+	self assert: (fast allWithType: FASTPyAssertStatement) size equals: 1.
+	self assert: (fast allWithType: FASTPyConcatenatedString) size equals: 1.
+	self assert: (fast allWithType: FASTPyInteger) size equals: 1.
+	self assert: (fast allWithType: FASTPyModule) size equals: 1.
+	self assert: (fast allWithType: FASTPyString) size equals: 2.
+
+	stack push: fast rootEntities anyOne containedEntities first.
+	self assert: self topEntity sourceCode equals: 'assert 0, "Could not find method in self.functions and no "\
+                          "instance installed"' withPlatformLineEndings.
+	self assert: (self topEntity isOfType: FASTPyAssertStatement).
+	
+	"Testing value of multivalued relation expressions"
+	self assert: self topEntity expressions size equals: 2.
+	
+		stack push: (stack top expressions at: 1).
+		self assert: self topEntity sourceCode equals: '0'.
+		self assert: (self topEntity isOfType: FASTPyInteger).
+		self assert: (self topEntity isOfType: FASTTLiteral).
+		self assert: (self topEntity isOfType: FASTTNumericalLiteral).
+		stack pop.
+	
+		stack push: (stack top expressions at: 2).
+		self assert: self topEntity sourceCode equals: '"Could not find method in self.functions and no "\
+                          "instance installed"' withPlatformLineEndings.
+		self assert: (self topEntity isOfType: FASTPyConcatenatedString).
+		
+		"Testing value of multivalued relation strings"
+		self assert: self topEntity strings size equals: 2.
+		
+			stack push: (stack top strings at: 1).
+			self assert: self topEntity sourceCode equals: '"Could not find method in self.functions and no "'.
+			self assert: (self topEntity isOfType: FASTPyString).
+			self assert: (self topEntity isOfType: FASTTLiteral).
+			self assert: (self topEntity isOfType: FASTTStringLiteral).
+			stack pop.
+		
+			stack push: (stack top strings at: 2).
+			self assert: self topEntity sourceCode equals: '"instance installed"'.
+			self assert: (self topEntity isOfType: FASTPyString).
+			self assert: (self topEntity isOfType: FASTTLiteral).
+			self assert: (self topEntity isOfType: FASTTStringLiteral)
+]
+
 { #category : 'tests' }
 FASTPythonImporterTest >> testAssignment [
 

src/FAST-Python-Tools/TSFASTPythonImporter.class.st

@@ -54,7 +54,9 @@ TSFASTPythonImporter >> visitArgumentList: aTSNode [
 { #category : 'visiting' }
 TSFASTPythonImporter >> visitAssertStatement: aTSNode [
 
-	^ self visitStatement: aTSNode
+	self onNextContextDo: [ :entry | entry add: #expressions asAliasOfField: '<unnamedChild>' ].
+
+	^ self handleNode: aTSNode kind: FASTPyAssertStatement
 ]
 
 { #category : 'visiting' }