Basic Lambda management

Author: jecisc

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

@@ -150,7 +150,8 @@ Class {
 		'tWithStatements',
 		'tNumericalLiteral',
 		'tComprehension',
-		'tWithCondition'
+		'tWithCondition',
+		'tWithParameters'
 	],
 	#category : 'FAST-Python-Model-Generator',
 	#package : 'FAST-Python-Model-Generator'
@@ -406,6 +407,9 @@ FASTPythonMetamodelGenerator >> defineHierarchy [
 	keywordArgument --|> expression.
 	keywordArgument --|> tNamedEntity.
 
+	lambda --|> expression.
+	lambda --|> tWithParameters.
+	
 	list --|> collectionInitializer.
 
 	listComprehension --|> expression.
@@ -562,6 +566,8 @@ FASTPythonMetamodelGenerator >> defineRelations [
 
 	((keywordArgument property: #value) comment: 'The value of the keyword argument.')
 	<>- ((expression property: #keywordArgumentOwner) comment: 'Keyword argument from which I am the value (if it''s the case)').
+	
+	(lambda property: #expression) <>- (expression property: #lambdaOwner).
 
 	((listSplat property: #iterable) comment: 'The iterable to unpack. Can be a collection, a call, an attribute access or a subscript.')
 	<>- ((expression property: #listSplatOwner) comment: 'List splat unpacking me (if it''s the case)').
@@ -625,5 +631,6 @@ FASTPythonMetamodelGenerator >> defineTraits [
 	tStringLiteral := self remoteTrait: #TStringLiteral withPrefix: #FAST.
 	tVariableEntity := self remoteTrait: #TVariableEntity withPrefix: #FAST.
 	tWithCondition := self remoteTrait: #TWithCondition withPrefix: #FAST.
+	tWithParameters := self remoteTrait: #TWithParameters withPrefix: #FAST.
 	tWithStatements := self remoteTrait: #TWithStatements withPrefix: #FAST
 ]

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

@@ -24,6 +24,7 @@
 | `forStatementRightOwner` | `FASTPyExpression` | `left` | `FASTPyForStatement` | The for statement owner (if possible)|
 | `ifClauseOwner` | `FASTPyExpression` | `expression` | `FASTPyIfClause` | |
 | `keywordArgumentOwner` | `FASTPyExpression` | `value` | `FASTPyKeywordArgument` | Keyword argument from which I am the value (if it's the case)|
+| `lambdaOwner` | `FASTPyExpression` | `expression` | `FASTPyLambda` | |
 | `listSplatOwner` | `FASTPyExpression` | `iterable` | `FASTPyListSplat` | List splat unpacking me (if it's the case)|
 | `pairKeyOwner` | `FASTTExpression` | `key` | `FASTPyPair` | |
 | `pairValueOwner` | `FASTTExpression` | `value` | `FASTPyPair` | |
@@ -72,6 +73,7 @@ Class {
 		'#forStatementRightOwner => FMOne type: #FASTPyForStatement opposite: #left',
 		'#ifClauseOwner => FMOne type: #FASTPyIfClause opposite: #expression',
 		'#keywordArgumentOwner => FMOne type: #FASTPyKeywordArgument opposite: #value',
+		'#lambdaOwner => FMOne type: #FASTPyLambda opposite: #expression',
 		'#listSplatOwner => FMOne type: #FASTPyListSplat opposite: #iterable',
 		'#parentComparisonOperator => FMOne type: #FASTPyComparisonOperator opposite: #operands',
 		'#parentUnaryOperator => FMOne type: #FASTPyTUnaryOperator opposite: #argument',
@@ -484,6 +486,30 @@ FASTPyExpression >> keywordArgumentOwnerGroup [
 	^ MooseSpecializedGroup with: self keywordArgumentOwner
 ]
 
+{ #category : 'accessing' }
+FASTPyExpression >> lambdaOwner [
+	"Relation named: #lambdaOwner type: #FASTPyLambda opposite: #expression"
+
+	<generated>
+	<container>
+	<derived>
+	^ lambdaOwner
+]
+
+{ #category : 'accessing' }
+FASTPyExpression >> lambdaOwner: anObject [
+
+	<generated>
+	lambdaOwner := anObject
+]
+
+{ #category : 'navigation' }
+FASTPyExpression >> lambdaOwnerGroup [
+	<generated>
+	<navigation: 'LambdaOwner'>
+	^ MooseSpecializedGroup with: self lambdaOwner
+]
+
 { #category : 'accessing' }
 FASTPyExpression >> listSplatOwner [
 	"Relation named: #listSplatOwner type: #FASTPyListSplat opposite: #iterable"

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

@@ -1,6 +1,24 @@
+"
+## Relations
+======================
+
+### Children
+| Relation | Origin | Opposite | Type | Comment |
+|---|
+| `expression` | `FASTPyLambda` | `lambdaOwner` | `FASTPyExpression` | |
+| `parameters` | `FASTTWithParameters` | `parameterOwner` | `FASTTVariableEntity` | My parameters|
+
+
+
+"
 Class {
 	#name : 'FASTPyLambda',
-	#superclass : 'FASTPyEntity',
+	#superclass : 'FASTPyExpression',
+	#traits : 'FASTTWithParameters',
+	#classTraits : 'FASTTWithParameters classTrait',
+	#instVars : [
+		'#expression => FMOne type: #FASTPyExpression opposite: #lambdaOwner'
+	],
 	#category : 'FAST-Python-Model-Entities',
 	#package : 'FAST-Python-Model',
 	#tag : 'Entities'
@@ -9,8 +27,30 @@ Class {
 { #category : 'meta' }
 FASTPyLambda class >> annotation [
 
-	<FMClass: #Lambda super: #FASTPyEntity>
+	<FMClass: #Lambda super: #FASTPyExpression>
 	<package: #'FAST-Python-Model'>
 	<generated>
 	^ self
 ]
+
+{ #category : 'accessing' }
+FASTPyLambda >> expression [
+	"Relation named: #expression type: #FASTPyExpression opposite: #lambdaOwner"
+
+	<generated>
+	^ expression
+]
+
+{ #category : 'accessing' }
+FASTPyLambda >> expression: anObject [
+
+	<generated>
+	expression := anObject
+]
+
+{ #category : 'navigation' }
+FASTPyLambda >> expressionGroup [
+	<generated>
+	<navigation: 'Expression'>
+	^ MooseSpecializedGroup with: self expression
+]

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

@@ -3599,6 +3599,33 @@ FASTPythonImporterTest >> testInteger [
 	self assert: (boolean isOfType: FASTTLiteral)
 ]
 
+{ #category : 'tests - lambdas' }
+FASTPythonImporterTest >> testLambda [
+	<generated>
+	"Generated as regression test by FASTPyImporterTestGenerator>>#generateTestNamed:fromCode:protocol:
+	Regenerate executing: 	self regenerateTest: #testLambda 	"
+
+	self parse: 'lambda : 3'.
+
+	self assert: (fast allWithType: FASTPyInteger) size equals: 1.
+	self assert: (fast allWithType: FASTPyLambda) size equals: 1.
+	self assert: (fast allWithType: FASTPyModule) size equals: 1.
+
+	stack push: fast rootEntities anyOne containedEntities first.
+	self assert: self topEntity sourceCode equals: 'lambda : 3'.
+	self assert: (self topEntity isOfType: FASTPyLambda).
+	self assert: (self topEntity isOfType: FASTTWithParameters).
+	
+	"Testing value of monovalue relation expression"
+	self assert: self topEntity expression isNotNil.
+
+		stack push: self topEntity expression.
+		self assert: self topEntity sourceCode equals: '3'.
+		self assert: (self topEntity isOfType: FASTPyInteger).
+		self assert: (self topEntity isOfType: FASTTLiteral).
+		self assert: (self topEntity isOfType: FASTTNumericalLiteral)
+]
+
 { #category : 'tests - collections' }
 FASTPythonImporterTest >> testList [
 	<generated>

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

@@ -368,6 +368,14 @@ TSFASTPythonImporter >> visitInteger: aTSNode [
 			   ifFalse: [ FASTPyInteger ])
 ]
 
+{ #category : 'visiting' }
+TSFASTPythonImporter >> visitLambda: aTSNode [
+
+	self onNextContextDo: [ :entry | entry add: 'expression' asAliasOfField: 'body' ].
+
+	^ self createEntityForNode: aTSNode kind: FASTPyLambda
+]
+
 { #category : 'visiting' }
 TSFASTPythonImporter >> visitLineContinuation: aTSNode [
 	"We do not represent that in FAST, at least for the moment. So I skip this node and act as if the children were in my parent."