Add support of exec statement

Author: jecisc

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

@@ -154,7 +154,8 @@ Class {
 		'tSuperclass',
 		'tCallable',
 		'tSliceIndex',
-		'tAwaitable'
+		'tAwaitable',
+		'tExecutable'
 	],
 	#category : 'FAST-Python-Model-Generator',
 	#package : 'FAST-Python-Model-Generator'
@@ -370,6 +371,7 @@ FASTPythonMetamodelGenerator >> defineHierarchy [
 	conditionalExpression --|> tWithCondition.
 	conditionalExpression --|> tSuperclass.
 	conditionalExpression --|> tCallable.
+	conditionalExpression --|> tExecutable.
 
 	continueStatement --|> statement.
 
@@ -526,6 +528,7 @@ FASTPythonMetamodelGenerator >> defineHierarchy [
 	string --|> literal.
 	string --|> tStringLiteral.
 	string --|> tSplatExpression.
+	string --|> tExecutable.
 
 	subscript --|> expression.
 	subscript --|> tReturnReferenceable.
@@ -545,6 +548,7 @@ FASTPythonMetamodelGenerator >> defineHierarchy [
 	tReturnReferenceable --|> tSuperclass.
 	tReturnReferenceable --|> tCallable.
 	tReturnReferenceable --|> tAwaitable.
+	tReturnReferenceable --|> tExecutable.
 
 	thenClause --|> tStatementBlock.
 
@@ -681,6 +685,9 @@ FASTPythonMetamodelGenerator >> defineRelations [
 	<>- ((tDeletable property: #parentDeleteStatement) comment: 'The delete statement that own the expression (if it''s the case)').
 
 	(exceptClause property: #expressions) <>-* (expression property: #parentExceptClause). "We could point less things than expression, but in reality in Python any expression can be provided. It will just end up in runtime error."
+	
+	(execStatement property: #code) <>- (tExecutable property: #parentExecStatement).
+	(execStatement property: #scopes) <>-* (expression property: #parentExecStatementScopes).
 
 	(forInClause property: #left) <>- (expression property: #forInClauseLeftOwner).
 	(forInClause property: #right) <>- (expression property: #forInClauseRightOwner).
@@ -804,6 +811,8 @@ FASTPythonMetamodelGenerator >> defineTraits [
 
 	tDeletable := (builder newTraitNamed: #TDeletable) comment: 'I represent an expression that can be in a delete statement.'.
 
+	tExecutable := (builder newTraitNamed: #TExecutable) comment: 'I represent something that can be executed by an exec statement'.
+	
 	tPattern := (builder newTraitNamed: #TPattern) comment: 'I represent an entity that can be the pattern of a case clause in a match statement..'.
 
 	tRaised := (builder newTraitNamed: #TRaised) comment: 'I represent an expression that can give an exception to raise in a raise statement.'.

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

@@ -14,6 +14,7 @@
 | `parentClassDefinition` | `FASTPyTSuperclass` | `superclasses` | `FASTPyClassDefinition` | |
 | `parentDeclarator` | `FASTPyTDecoratorExpression` | `expression` | `FASTPyDecorator` | |
 | `parentDeleteStatement` | `FASTPyTDeletable` | `expression` | `FASTPyDeleteStatement` | The delete statement that own the expression (if it's the case)|
+| `parentExecStatement` | `FASTPyTExecutable` | `code` | `FASTPyExecStatement` | |
 | `parentRaiseStatement` | `FASTPyTRaised` | `exception` | `FASTPyRaiseStatement` | |
 | `parentSplat` | `FASTPyTSplatExpression` | `expression` | `FASTPySplat` | |
 | `parentSplatParameter` | `FASTPyTSplatParameterTarget` | `target` | `FASTPySplatParameter` | |

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

@@ -16,6 +16,7 @@
 | `parentConditional` | `FASTTExpression` | `condition` | `FASTTWithCondition` | Optional condition statement/expression where this expression is used|
 | `parentDeclarator` | `FASTPyTDecoratorExpression` | `expression` | `FASTPyDecorator` | |
 | `parentDeleteStatement` | `FASTPyTDeletable` | `expression` | `FASTPyDeleteStatement` | The delete statement that own the expression (if it's the case)|
+| `parentExecStatement` | `FASTPyTExecutable` | `code` | `FASTPyExecStatement` | |
 | `parentExpression` | `FASTTExpression` | `expression` | `FASTTUnaryExpression` | Parent (unary) expression|
 | `parentExpressionLeft` | `FASTTExpression` | `leftOperand` | `FASTTBinaryExpression` | Parent (binary) expression of which I am left side|
 | `parentExpressionRight` | `FASTTExpression` | `rightOperand` | `FASTTBinaryExpression` | Parent (binary) expression of which I am right side|

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

@@ -7,6 +7,7 @@
 |---|
 | `caller` | `FASTPyTCallable` | `callee` | `FASTPyCall` | The call entity calling me (if it's the case)|
 | `parentClassDefinition` | `FASTPyTSuperclass` | `superclasses` | `FASTPyClassDefinition` | |
+| `parentExecStatement` | `FASTPyTExecutable` | `code` | `FASTPyExecStatement` | |
 
 ### Children
 | Relation | Origin | Opposite | Type | Comment |
@@ -21,8 +22,8 @@
 Class {
 	#name : 'FASTPyConditionalExpression',
 	#superclass : 'FASTPyExpression',
-	#traits : 'FASTPyTCallable + FASTPyTSuperclass + FASTTWithCondition',
-	#classTraits : 'FASTPyTCallable classTrait + FASTPyTSuperclass classTrait + FASTTWithCondition classTrait',
+	#traits : 'FASTPyTCallable + FASTPyTExecutable + FASTPyTSuperclass + FASTTWithCondition',
+	#classTraits : 'FASTPyTCallable classTrait + FASTPyTExecutable classTrait + FASTPyTSuperclass classTrait + FASTTWithCondition classTrait',
 	#instVars : [
 		'#elseExpression => FMOne type: #FASTPyExpression opposite: #conditionalExpressionElseOwner',
 		'#thenExpression => FMOne type: #FASTPyExpression opposite: #conditionalExpressionThenOwner'

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

@@ -1,6 +1,23 @@
+"
+## Relations
+======================
+
+### Children
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `code` | `FASTPyExecStatement` | `parentExecStatement` | `FASTPyTExecutable` | |
+| `scopes` | `FASTPyExecStatement` | `parentExecStatementScopes` | `FASTPyExpression` | |
+
+
+
+"
 Class {
 	#name : 'FASTPyExecStatement',
 	#superclass : 'FASTPyStatement',
+	#instVars : [
+		'#code => FMOne type: #FASTPyTExecutable opposite: #parentExecStatement',
+		'#scopes => FMMany type: #FASTPyExpression opposite: #parentExecStatementScopes'
+	],
 	#category : 'FAST-Python-Model-Entities',
 	#package : 'FAST-Python-Model',
 	#tag : 'Entities'
@@ -14,3 +31,54 @@ FASTPyExecStatement class >> annotation [
 	<generated>
 	^ self
 ]
+
+{ #category : 'adding' }
+FASTPyExecStatement >> addScope: anObject [
+	<generated>
+	^ self scopes add: anObject
+]
+
+{ #category : 'accessing' }
+FASTPyExecStatement >> code [
+	"Relation named: #code type: #FASTPyTExecutable opposite: #parentExecStatement"
+
+	<generated>
+	^ code
+]
+
+{ #category : 'accessing' }
+FASTPyExecStatement >> code: anObject [
+
+	<generated>
+	code := anObject
+]
+
+{ #category : 'navigation' }
+FASTPyExecStatement >> codeGroup [
+	<generated>
+	<navigation: 'Code'>
+	^ MooseSpecializedGroup with: self code
+]
+
+{ #category : 'accessing' }
+FASTPyExecStatement >> scopes [
+	"Relation named: #scopes type: #FASTPyExpression opposite: #parentExecStatementScopes"
+
+	<generated>
+	<derived>
+	^ scopes
+]
+
+{ #category : 'accessing' }
+FASTPyExecStatement >> scopes: anObject [
+
+	<generated>
+	scopes value: anObject
+]
+
+{ #category : 'navigation' }
+FASTPyExecStatement >> scopesGroup [
+	<generated>
+	<navigation: 'Scopes'>
+	^ MooseSpecializedGroup withAll: self scopes asSet
+]

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

@@ -25,6 +25,7 @@
 | `parentConditional` | `FASTTExpression` | `condition` | `FASTTWithCondition` | Optional condition statement/expression where this expression is used|
 | `parentDefaultParameterValue` | `FASTPyExpression` | `defaultValue` | `FASTPyParameter` | |
 | `parentExceptClause` | `FASTPyExpression` | `expressions` | `FASTPyExceptClause` | |
+| `parentExecStatementScopes` | `FASTPyExpression` | `scopes` | `FASTPyExecStatement` | |
 | `parentExpression` | `FASTTExpression` | `expression` | `FASTTUnaryExpression` | Parent (unary) expression|
 | `parentExpressionLeft` | `FASTTExpression` | `leftOperand` | `FASTTBinaryExpression` | Parent (binary) expression of which I am left side|
 | `parentExpressionRight` | `FASTTExpression` | `rightOperand` | `FASTTBinaryExpression` | Parent (binary) expression of which I am right side|
@@ -77,6 +78,7 @@ Class {
 		'#parentComprehensionForClause => FMOne type: #FASTPyComprehension opposite: #forClauses',
 		'#parentDefaultParameterValue => FMOne type: #FASTPyParameter opposite: #defaultValue',
 		'#parentExceptClause => FMOne type: #FASTPyExceptClause opposite: #expressions',
+		'#parentExecStatementScopes => FMOne type: #FASTPyExecStatement opposite: #scopes',
 		'#parentForStatementLeft => FMOne type: #FASTPyForStatement opposite: #right',
 		'#parentForStatementRight => FMOne type: #FASTPyForStatement opposite: #left',
 		'#parentIfClause => FMOne type: #FASTPyIfClause opposite: #expression',
@@ -488,6 +490,29 @@ FASTPyExpression >> parentExceptClauseGroup [
 	^ MooseSpecializedGroup with: self parentExceptClause
 ]
 
+{ #category : 'accessing' }
+FASTPyExpression >> parentExecStatementScopes [
+	"Relation named: #parentExecStatementScopes type: #FASTPyExecStatement opposite: #scopes"
+
+	<generated>
+	<container>
+	^ parentExecStatementScopes
+]
+
+{ #category : 'accessing' }
+FASTPyExpression >> parentExecStatementScopes: anObject [
+
+	<generated>
+	parentExecStatementScopes := anObject
+]
+
+{ #category : 'navigation' }
+FASTPyExpression >> parentExecStatementScopesGroup [
+	<generated>
+	<navigation: 'ParentExecStatementScopes'>
+	^ MooseSpecializedGroup with: self parentExecStatementScopes
+]
+
 { #category : 'accessing' }
 FASTPyExpression >> parentForStatementLeft [
 	"Relation named: #parentForStatementLeft type: #FASTPyForStatement opposite: #right"

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

@@ -13,6 +13,7 @@
 | `parentClassDefinition` | `FASTPyTSuperclass` | `superclasses` | `FASTPyClassDefinition` | |
 | `parentDeclarator` | `FASTPyTDecoratorExpression` | `expression` | `FASTPyDecorator` | |
 | `parentDeleteStatement` | `FASTPyTDeletable` | `expression` | `FASTPyDeleteStatement` | The delete statement that own the expression (if it's the case)|
+| `parentExecStatement` | `FASTPyTExecutable` | `code` | `FASTPyExecStatement` | |
 | `parentRaiseStatement` | `FASTPyTRaised` | `exception` | `FASTPyRaiseStatement` | |
 | `parentSplat` | `FASTPyTSplatExpression` | `expression` | `FASTPySplat` | |
 | `parentSplatParameter` | `FASTPyTSplatParameterTarget` | `target` | `FASTPySplatParameter` | |

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

@@ -10,6 +10,7 @@
 | `expressionStatementOwner` | `FASTTExpression` | `expression` | `FASTTExpressionStatement` | The expression statement that own me (if it's the case|
 | `parentConcatenatedString` | `FASTPyString` | `strings` | `FASTPyConcatenatedString` | |
 | `parentConditional` | `FASTTExpression` | `condition` | `FASTTWithCondition` | Optional condition statement/expression where this expression is used|
+| `parentExecStatement` | `FASTPyTExecutable` | `code` | `FASTPyExecStatement` | |
 | `parentExpression` | `FASTTExpression` | `expression` | `FASTTUnaryExpression` | Parent (unary) expression|
 | `parentExpressionLeft` | `FASTTExpression` | `leftOperand` | `FASTTBinaryExpression` | Parent (binary) expression of which I am left side|
 | `parentExpressionRight` | `FASTTExpression` | `rightOperand` | `FASTTBinaryExpression` | Parent (binary) expression of which I am right side|
@@ -35,8 +36,8 @@
 Class {
 	#name : 'FASTPyString',
 	#superclass : 'FASTPyLiteral',
-	#traits : 'FASTPyTSplatExpression + FASTTStringLiteral',
-	#classTraits : 'FASTPyTSplatExpression classTrait + FASTTStringLiteral classTrait',
+	#traits : 'FASTPyTExecutable + FASTPyTSplatExpression + FASTTStringLiteral',
+	#classTraits : 'FASTPyTExecutable classTrait + FASTPyTSplatExpression classTrait + FASTTStringLiteral classTrait',
 	#instVars : [
 		'#interpolations => FMMany type: #FASTPyInterpolation opposite: #parentString',
 		'#parentConcatenatedString => FMOne type: #FASTPyConcatenatedString opposite: #strings'

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

@@ -13,6 +13,7 @@
 | `parentClassDefinition` | `FASTPyTSuperclass` | `superclasses` | `FASTPyClassDefinition` | |
 | `parentDeclarator` | `FASTPyTDecoratorExpression` | `expression` | `FASTPyDecorator` | |
 | `parentDeleteStatement` | `FASTPyTDeletable` | `expression` | `FASTPyDeleteStatement` | The delete statement that own the expression (if it's the case)|
+| `parentExecStatement` | `FASTPyTExecutable` | `code` | `FASTPyExecStatement` | |
 | `parentRaiseStatement` | `FASTPyTRaised` | `exception` | `FASTPyRaiseStatement` | |
 | `parentSplat` | `FASTPyTSplatExpression` | `expression` | `FASTPySplat` | |
 

src/FAST-Python-Model/FASTPyTExecutable.trait.st

@@ -0,0 +1,56 @@
+"
+I represent something that can be executed by an exec statement
+
+## Relations
+======================
+
+### Parents
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `parentExecStatement` | `FASTPyTExecutable` | `code` | `FASTPyExecStatement` | |
+
+
+
+"
+Trait {
+	#name : 'FASTPyTExecutable',
+	#instVars : [
+		'#parentExecStatement => FMOne type: #FASTPyExecStatement opposite: #code'
+	],
+	#category : 'FAST-Python-Model-Traits',
+	#package : 'FAST-Python-Model',
+	#tag : 'Traits'
+}
+
+{ #category : 'meta' }
+FASTPyTExecutable classSide >> annotation [
+
+	<FMClass: #TExecutable super: #Object>
+	<package: #'FAST-Python-Model'>
+	<generated>
+	^ self
+]
+
+{ #category : 'accessing' }
+FASTPyTExecutable >> parentExecStatement [
+	"Relation named: #parentExecStatement type: #FASTPyExecStatement opposite: #code"
+
+	<generated>
+	<container>
+	<derived>
+	^ parentExecStatement
+]
+
+{ #category : 'accessing' }
+FASTPyTExecutable >> parentExecStatement: anObject [
+
+	<generated>
+	parentExecStatement := anObject
+]
+
+{ #category : 'navigation' }
+FASTPyTExecutable >> parentExecStatementGroup [
+	<generated>
+	<navigation: 'ParentExecStatement'>
+	^ MooseSpecializedGroup with: self parentExecStatement
+]