Reuse type for generated execute function. Also refactor ast node cre…

…ation

bbq/compiler/desugar.go

@@ -1080,39 +1080,62 @@ func (d *Desugar) VisitTransactionDeclaration(transaction *ast.TransactionDeclar
 		for index, parameter := range transaction.ParameterList.Parameters {
 			// Create global variables
 			// i.e: `var a: Type`
-			field := &ast.VariableDeclaration{
-				Access:         ast.AccessSelf,
-				IsConstant:     false,
-				Identifier:     parameter.Identifier,
-				TypeAnnotation: parameter.TypeAnnotation,
-			}
+			field := ast.NewVariableDeclaration(
+				d.memoryGauge,
+				ast.AccessSelf,
+				false,
+				parameter.Identifier,
+				parameter.TypeAnnotation,
+				nil,
+				nil,
+				parameter.StartPos,
+				nil,
+				nil,
+				"",
+			)
+
 			varDeclarations = append(varDeclarations, field)
 
 			// Create assignment from param to global var.
 			// i.e: `a = $param_a`
 			modifiedParamName := commons.TransactionGeneratedParamPrefix + parameter.Identifier.Identifier
-			modifiedParameter := &ast.Parameter{
-				Label: "",
-				Identifier: ast.Identifier{
-					Identifier: modifiedParamName,
-				},
-				TypeAnnotation: parameter.TypeAnnotation,
-			}
+
+			modifiedParameter := ast.NewParameter(
+				d.memoryGauge,
+				"",
+				ast.NewIdentifier(
+					d.memoryGauge,
+					modifiedParamName,
+					parameter.StartPos,
+				),
+				parameter.TypeAnnotation,
+				nil,
+				parameter.StartPos,
+			)
+
 			parameters = append(parameters, modifiedParameter)
 
-			assignment := &ast.AssignmentStatement{
-				Target: &ast.IdentifierExpression{
-					Identifier: parameter.Identifier,
-				},
-				Value: &ast.IdentifierExpression{
-					Identifier: ast.Identifier{
-						Identifier: modifiedParamName,
-					},
-				},
-				Transfer: &ast.Transfer{
-					Operation: ast.TransferOperationCopy,
-				},
-			}
+			assignment := ast.NewAssignmentStatement(
+				d.memoryGauge,
+				ast.NewIdentifierExpression(
+					d.memoryGauge,
+					parameter.Identifier,
+				),
+				ast.NewTransfer(
+					d.memoryGauge,
+					ast.TransferOperationCopy,
+					parameter.StartPos,
+				),
+				ast.NewIdentifierExpression(
+					d.memoryGauge,
+					ast.NewIdentifier(
+						d.memoryGauge,
+						modifiedParamName,
+						parameter.StartPos,
+					),
+				),
+			)
+
 			statements = append(statements, assignment)
 
 			transactionTypes := d.elaboration.TransactionDeclarationType(transaction)
@@ -1131,21 +1154,14 @@ func (d *Desugar) VisitTransactionDeclaration(transaction *ast.TransactionDeclar
 		//     b = $param_b
 		//     ...
 		// }
-		initFunction = &ast.FunctionDeclaration{
-			Access: ast.AccessNotSpecified,
-			Identifier: ast.Identifier{
-				Identifier: commons.ProgramInitFunctionName,
-			},
-			ParameterList: &ast.ParameterList{
-				Parameters: parameters,
-			},
-			ReturnTypeAnnotation: nil,
-			FunctionBlock: &ast.FunctionBlock{
-				Block: &ast.Block{
-					Statements: statements,
-				},
-			},
-		}
+		initFunction = simpleFunctionDeclaration(
+			d.memoryGauge,
+			commons.ProgramInitFunctionName,
+			parameters,
+			statements,
+			transaction.StartPos,
+			transaction.Range,
+		)
 	}
 
 	var members []ast.Declaration
@@ -1169,21 +1185,13 @@ func (d *Desugar) VisitTransactionDeclaration(transaction *ast.TransactionDeclar
 	if preConditions != nil || postConditions != nil {
 		if executeFunc == nil {
 			// If there is no execute block, create an empty one.
-			executeFunc = &ast.FunctionDeclaration{
-				Access: ast.AccessNotSpecified,
-				Identifier: ast.Identifier{
-					Identifier: commons.ExecuteFunctionName,
-				},
-				ReturnTypeAnnotation: nil,
-				FunctionBlock: &ast.FunctionBlock{
-					Block: &ast.Block{},
-				},
-			}
-
-			executeFuncType := sema.NewSimpleFunctionType(
-				sema.FunctionPurityImpure,
+			executeFunc = simpleFunctionDeclaration(
+				d.memoryGauge,
+				commons.ExecuteFunctionName,
+				nil,
 				nil,
-				sema.VoidTypeAnnotation,
+				transaction.StartPos,
+				transaction.Range,
 			)
 
 			d.elaboration.SetFunctionDeclarationFunctionType(executeFunc, executeFuncType)
@@ -1200,14 +1208,6 @@ func (d *Desugar) VisitTransactionDeclaration(transaction *ast.TransactionDeclar
 		members = append(members, desugaredExecuteFunc)
 	}
 
-	compositeType := &sema.CompositeType{
-		Location:    nil,
-		Identifier:  commons.TransactionWrapperCompositeName,
-		Kind:        common.CompositeKindStructure,
-		NestedTypes: &sema.StringTypeOrderedMap{},
-		Members:     &sema.StringMemberOrderedMap{},
-	}
-
 	compositeDecl := ast.NewCompositeDeclaration(
 		d.memoryGauge,
 		ast.AccessNotSpecified,
@@ -1223,7 +1223,7 @@ func (d *Desugar) VisitTransactionDeclaration(transaction *ast.TransactionDeclar
 		ast.EmptyRange,
 	)
 
-	d.elaboration.SetCompositeDeclarationType(compositeDecl, compositeType)
+	d.elaboration.SetCompositeDeclarationType(compositeDecl, transactionCompositeType)
 
 	// We can only return one declaration.
 	// So manually add the rest of the declarations.
@@ -1303,3 +1303,64 @@ var emptyInitializer = func() *ast.SpecialFunctionDeclaration {
 		initializer,
 	)
 }()
+
+func simpleFunctionDeclaration(
+	memoryGauge common.MemoryGauge,
+	functionName string,
+	parameters []*ast.Parameter,
+	statements []ast.Statement,
+	startPos ast.Position,
+	astRange ast.Range,
+) *ast.FunctionDeclaration {
+
+	var paramList *ast.ParameterList
+	if parameters != nil {
+		paramList = ast.NewParameterList(
+			memoryGauge,
+			parameters,
+			astRange,
+		)
+	}
+
+	return ast.NewFunctionDeclaration(
+		memoryGauge,
+		ast.AccessNotSpecified,
+		ast.FunctionPurityUnspecified,
+		false,
+		false,
+		ast.NewIdentifier(
+			memoryGauge,
+			functionName,
+			startPos,
+		),
+		nil,
+		paramList,
+		nil,
+		ast.NewFunctionBlock(
+			memoryGauge,
+			ast.NewBlock(
+				memoryGauge,
+				statements,
+				astRange,
+			),
+			nil,
+			nil,
+		),
+		startPos,
+		"",
+	)
+}
+
+var transactionCompositeType = &sema.CompositeType{
+	Location:    nil,
+	Identifier:  commons.TransactionWrapperCompositeName,
+	Kind:        common.CompositeKindStructure,
+	NestedTypes: &sema.StringTypeOrderedMap{},
+	Members:     &sema.StringMemberOrderedMap{},
+}
+
+var executeFuncType = sema.NewSimpleFunctionType(
+	sema.FunctionPurityImpure,
+	nil,
+	sema.VoidTypeAnnotation,
+)