Merge pull request #41 from cpfr/closures

Closures and bug fixes
MontysCoconut · Nov 25, 2015 · 19e46c9 · 19e46c9
2 parents 77e31b7 + 7c52f0c
commit 19e46c9
Show file tree

Hide file tree

Showing 35 changed files with 580 additions and 111 deletions.
diff --git a/src/main/antlr4/de/uni/bremen/monty/moco/antlr/Monty.g4 b/src/main/antlr4/de/uni/bremen/monty/moco/antlr/Monty.g4
@@ -2,6 +2,11 @@ grammar Monty;
 
 import lex;
 
+
+nativeAnnotation
+  : '@native'
+  ;
+
 compilationUnit
   : EndOfLine* moduleDeclaration EOF
   ;
@@ -28,7 +33,7 @@ independentDeclaration
   ;
 
 classDeclaration
-  : AbstractKeyword? 'class' type ('inherits' typeList)?
+  : nativeAnnotation? AbstractKeyword? 'class' type ('inherits' typeList)?
     ':' EndOfLine
     Indent
         (memberDeclaration+ | 'pass' EndOfLine)
@@ -83,7 +88,7 @@ typeList
   ;
 
 functionDeclaration
-  : (type)?
+  : nativeAnnotation? (type)?
     Identifier
     Lparenthesis parameterList? Rparenthesis ':' EndOfLine
     statementBlock
@@ -193,9 +198,9 @@ expressionList
   ;
 
 expression
-  : functionCall
-  | primary
+  : primary
   | functionExpression
+  | functionCall
   | ifExprThen=expression 'if' ifExpCondition=expression 'else' ifExprElse=expression
   | left=expression accessOperator right=expression
   | <assoc=right> (plusMinusOperator | notOperator) singleExpression=expression

diff --git a/src/main/java/de/uni/bremen/monty/moco/ast/ASTBuilder.java b/src/main/java/de/uni/bremen/monty/moco/ast/ASTBuilder.java
@@ -233,7 +233,8 @@ public ASTNode visitFunctionCall(FunctionCallContext ctx) {
 	private void buildDefaultFunctions(boolean isFunction, List<DefaultParameterContext> defaultParameter,
 	        List<VariableDeclaration> allVariableDeclarations, List<VariableDeclaration> params,
 	        List<Expression> defaultExpression, List<VariableDeclaration> defaultVariableDeclaration,
-	        Identifier identifier, Token token, TypeContext typeContext, DeclarationType declarationTypeCopy) {
+	        Identifier identifier, Token token, TypeContext typeContext, DeclarationType declarationTypeCopy,
+	        boolean isNative) {
 
 		for (int defaultParameterIdx = 0; defaultParameterIdx < defaultParameter.size(); defaultParameterIdx++) {
 			Block block = new Block(position(token));
@@ -252,8 +253,12 @@ private void buildDefaultFunctions(boolean isFunction, List<DefaultParameterCont
 				}
 			}
 
-			List<VariableDeclaration> subParams =
-			        allVariableDeclarations.subList(0, params.size() + defaultParameterIdx);
+			List<VariableDeclaration> subParams = new ArrayList<>(params.size() + defaultParameterIdx);
+			for (int i = 0; i < params.size() + defaultParameterIdx; i++) {
+				VariableDeclaration var = allVariableDeclarations.get(i);
+				subParams.add(new VariableDeclaration(var.getPosition(), var.getIdentifier(), var.getTypeIdentifier(),
+				        var.getDeclarationType()));
+			}
 
 			Expression expression =
 			        new FunctionCall(position(token), new ResolvableIdentifier(identifier.getSymbol()), l);
@@ -275,13 +280,15 @@ private void buildDefaultFunctions(boolean isFunction, List<DefaultParameterCont
 			FunctionDeclaration funDecl =
 			        new FunctionDeclaration(position(token), identifier, block, subParams, declarationTypeCopy,
 			                returnTypeIdent);
+			funDecl.setNative(isNative);
 
 			currentBlocks.peek().addDeclaration(funDecl);
 		}
 	}
 
 	private FunctionDeclaration buildFunctions(boolean isFunction, ParameterListContext parameterListContext,
-	        Token token, TypeContext typeContext, StatementBlockContext statementBlockContext, Identifier identifier) {
+	        Token token, TypeContext typeContext, StatementBlockContext statementBlockContext, Identifier identifier,
+	        boolean isNative) {
 
 		FunctionDeclaration.DeclarationType declarationTypeCopy = currentFunctionContext;
 		List<VariableDeclaration> params = parameterListToVarDeclList(parameterListContext);
@@ -308,7 +315,8 @@ private FunctionDeclaration buildFunctions(boolean isFunction, ParameterListCont
 		        identifier,
 		        token,
 		        typeContext,
-		        declarationTypeCopy);
+		        declarationTypeCopy,
+		        isNative);
 
 		FunctionDeclaration funDecl;
 
@@ -320,6 +328,7 @@ private FunctionDeclaration buildFunctions(boolean isFunction, ParameterListCont
 		funDecl =
 		        new FunctionDeclaration(position(token), identifier, (Block) visit(statementBlockContext),
 		                allVariableDeclarations, declarationTypeCopy, returnTypeIdent);
+		funDecl.setNative(isNative);
 		if (funDecl.isUnbound()) {
 			FunctionWrapperFactory.generateWrapperClass(funDecl, tupleDeclarationFactory);
 			currentBlocks.peek().addDeclaration(funDecl.getWrapperClass());
@@ -350,14 +359,16 @@ private FunctionDeclaration buildAbstractMethod(boolean functionDeclaration,
 	@Override
 	public ASTNode visitFunctionDeclaration(FunctionDeclarationContext ctx) {
 		currentGeneratorReturnType.push(null);
+		boolean isNativeFunction = ctx.nativeAnnotation() != null;
 		FunctionDeclaration proc =
 		        buildFunctions(
 		                ctx.type() != null,
 		                ctx.parameterList(),
 		                ctx.getStart(),
 		                ctx.type(),
 		                ctx.statementBlock(),
-		                new Identifier(getText(ctx.Identifier())));
+		                new Identifier(getText(ctx.Identifier())),
+		                isNativeFunction);
 		// if the function does not have any return type, we have to add a return statement
 		if (ctx.type() == null) {
 			List<Statement> list = proc.getBody().getStatements();
@@ -398,8 +409,14 @@ private ASTNode createGenerator(Position pos, ResolvableIdentifier className, Re
 		allParams.addAll(params);
 		allParams.addAll(defaultParams);
 
+		List<VariableDeclaration> allParamsCopy = new ArrayList<>(allParams.size());
+		for (VariableDeclaration param : allParams) {
+			allParamsCopy.add(new VariableDeclaration(param.getPosition(), param.getIdentifier(),
+			        param.getTypeIdentifier(), param.getDeclarationType()));
+		}
+
 		ClassDeclaration iterator =
-		        GeneratorClassFactory.generateGeneratorIteratorClass(pos, allParams, body, returnType);
+		        GeneratorClassFactory.generateGeneratorIteratorClass(pos, allParamsCopy, body, returnType);
 		currentBlocks.peek().addDeclaration(iterator);
 
 		ClassDeclaration generator =

diff --git a/src/main/java/de/uni/bremen/monty/moco/ast/BasicASTNode.java b/src/main/java/de/uni/bremen/monty/moco/ast/BasicASTNode.java
@@ -56,6 +56,8 @@ public abstract class BasicASTNode implements ASTNode {
 
 	private BitSet visitedFlags = new BitSet(NUMBER_OF_VISITORS);
 
+	private boolean isNativeNode = false;
+
 	/** Constructor.
 	 *
 	 * @param position
@@ -82,7 +84,7 @@ public ASTNode getParentNode() {
 	 *
 	 * @return the parent node */
 	public ASTNode getParentNodeByType(Class type) {
-		ASTNode n = this;
+		ASTNode n = getParentNode();
 		while ((!type.isInstance(n)) && (n != null)) {
 			n = n.getParentNode();
 		}
@@ -128,4 +130,12 @@ public Scope getScope() {
 	public BitSet getVisitedFlags() {
 		return visitedFlags;
 	}
+
+	public boolean isNative() {
+		return isNativeNode;
+	}
+
+	public void setNative(boolean isNative) {
+		isNativeNode = isNative;
+	}
 }
diff --git a/src/main/java/de/uni/bremen/monty/moco/ast/ClassScope.java b/src/main/java/de/uni/bremen/monty/moco/ast/ClassScope.java
@@ -109,12 +109,16 @@ protected Declaration resolveMember(ResolvableIdentifier identifier) {
 	 * @param identifier
 	 *            the identifier to resolve
 	 * @return the list of function declarations */
-	protected List<FunctionDeclaration> resolveFunctionMember(ResolvableIdentifier identifier) {
-		List<FunctionDeclaration> result = new ArrayList<FunctionDeclaration>();
+	protected List<Declaration> resolveFunctionMember(ResolvableIdentifier identifier) {
+		List<Declaration> result = new ArrayList<>();
 
 		if (functions.containsKey(identifier)) {
 			result.addAll(functions.get(identifier));
 		}
+		if (members.containsKey(identifier)) {
+			result.add(members.get(identifier));
+		}
+
 		for (ClassScope scope : parentClassesScopes) {
 			result.addAll(scope.resolveFunctionMember(identifier));
 		}

diff --git a/src/main/java/de/uni/bremen/monty/moco/ast/declaration/FunctionDeclaration.java b/src/main/java/de/uni/bremen/monty/moco/ast/declaration/FunctionDeclaration.java
@@ -44,10 +44,10 @@
 import de.uni.bremen.monty.moco.ast.expression.WrappedFunctionCall;
 import de.uni.bremen.monty.moco.ast.statement.Assignment;
 import de.uni.bremen.monty.moco.ast.statement.ReturnStatement;
+import de.uni.bremen.monty.moco.ast.statement.Statement;
 import de.uni.bremen.monty.moco.visitor.BaseVisitor;
 
-import java.util.ArrayList;
-import java.util.List;
+import java.util.*;
 
 /** A FunctionDeclaration represents the declaration of a function in the AST.
  * <p>
@@ -80,6 +80,8 @@ public enum DeclarationType {
 
 	private boolean returnTypeMustBeInferred = false;
 
+	private Map<VariableDeclaration, VariableDeclaration> closureVars = new HashMap<>();
+
 	/** Constructor.
 	 *
 	 * @param position
@@ -396,10 +398,9 @@ protected void splitReturnStatement(boolean tupleInsteadOfVoid) {
 		// add the new ones
 		Expression oldCall = oldRet.getParameter();
 		oldCall.setParentNode(getBody());
-		if (oldCall instanceof FunctionCall) {
-			getBody().addStatement((FunctionCall) oldCall);
-		} else if (oldCall instanceof WrappedFunctionCall) {
-			getBody().addStatement((WrappedFunctionCall) oldCall);
+
+		if (oldCall instanceof Statement) {
+			getBody().addStatement((Statement) oldCall);
 		} else {
 			throw new RuntimeException("invalid AST!");
 		}
@@ -414,4 +415,47 @@ public String toString() {
 		}
 		return String.format("%s(%s)", getIdentifier().toString(), params);
 	}
+
+	private VariableDeclaration checkSelfVariable(VariableDeclaration var) {
+		if (var.getIdentifier().getSymbol().equals("self")) {
+			for (VariableDeclaration key : closureVars.keySet()) {
+				if (key.getIdentifier().getSymbol().equals("self")) {
+					return key;
+				}
+			}
+		}
+		return var;
+	}
+
+	public VariableDeclaration addClosureVariable(VariableDeclaration var) {
+		var = checkSelfVariable(var);
+		if (!closureVars.containsKey(var)) {
+			VariableDeclaration attr =
+			        new VariableDeclaration(var.getPosition(), var.getIdentifier(), var.getTypeIdentifier(),
+			                VariableDeclaration.DeclarationType.ATTRIBUTE);
+			attr.setParentNode(var.getParentNode());
+			attr.setScope(var.getScope());
+			attr.setType(var.getType());
+			closureVars.put(var, attr);
+			return attr;
+		}
+		return closureVars.get(var);
+	}
+
+	public boolean isClosure() {
+		return closureVars.size() > 0;
+	}
+
+	public VariableDeclaration getClosureVariable(VariableDeclaration var) {
+		var = checkSelfVariable(var);
+		return closureVars.get(var);
+	}
+
+	public Collection<VariableDeclaration> getClosureVariables() {
+		return closureVars.values();
+	}
+
+	public Collection<VariableDeclaration> getClosureVariableOriginalDeclarations() {
+		return closureVars.keySet();
+	}
 }
diff --git a/src/main/java/de/uni/bremen/monty/moco/ast/declaration/ModuleDeclaration.java b/src/main/java/de/uni/bremen/monty/moco/ast/declaration/ModuleDeclaration.java
@@ -98,8 +98,4 @@ public void visitChildren(BaseVisitor visitor) {
 		}
 		visitor.visitDoubleDispatched(block);
 	}
-
-	public boolean isNative() {
-		return !getIdentifier().getSymbol().startsWith("_");
-	}
 }
diff --git a/src/main/java/de/uni/bremen/monty/moco/ast/expression/SelfExpression.java b/src/main/java/de/uni/bremen/monty/moco/ast/expression/SelfExpression.java
@@ -42,6 +42,7 @@
 import de.uni.bremen.monty.moco.visitor.BaseVisitor;
 
 public class SelfExpression extends Expression {
+	private boolean inClosure = false;
 
 	public SelfExpression(Position position) {
 		super(position);
@@ -55,4 +56,12 @@ public void visit(BaseVisitor visitor) {
 	@Override
 	public void visitChildren(BaseVisitor visitor) {
 	}
+
+	public void setInClosure() {
+		inClosure = true;
+	}
+
+	public boolean isInClosure() {
+		return inClosure;
+	}
 }
diff --git a/src/main/java/de/uni/bremen/monty/moco/ast/expression/VariableAccess.java b/src/main/java/de/uni/bremen/monty/moco/ast/expression/VariableAccess.java
@@ -49,6 +49,7 @@ public class VariableAccess extends Expression {
 	/** Identifier of the variable to access. */
 	private final ResolvableIdentifier identifier;
 	private Declaration declaration;
+	private boolean isClosureVar = false;
 
 	/** Is this a L-value? */
 	private boolean lValue = false;
@@ -98,4 +99,12 @@ public Declaration getDeclaration() {
 	public void setDeclaration(Declaration declaration) {
 		this.declaration = declaration;
 	}
+
+	public void setClosureVariable(boolean closure) {
+		isClosureVar = closure;
+	}
+
+	public boolean isClosureVariable() {
+		return isClosureVar;
+	}
 }
diff --git a/src/main/java/de/uni/bremen/monty/moco/ast/statement/Assignment.java b/src/main/java/de/uni/bremen/monty/moco/ast/statement/Assignment.java
@@ -39,6 +39,7 @@
 package de.uni.bremen.monty.moco.ast.statement;
 
 import de.uni.bremen.monty.moco.ast.*;
+import de.uni.bremen.monty.moco.ast.declaration.FunctionDeclaration;
 import de.uni.bremen.monty.moco.ast.expression.Expression;
 import de.uni.bremen.monty.moco.visitor.BaseVisitor;
 
@@ -50,6 +51,8 @@ public class Assignment extends BasicASTNode implements Statement {
 	/** The right side. */
 	private final Expression right;
 
+	private FunctionDeclaration correspondingFunWrapper = null;
+
 	/** Constructor.
 	 *
 	 * @param position
@@ -91,4 +94,15 @@ public void visitChildren(BaseVisitor visitor) {
 		visitor.visitDoubleDispatched(right);
 	}
 
+	public boolean belongsToFunctionWrapper() {
+		return correspondingFunWrapper != null;
+	}
+
+	public void setCorrespondingFunctionWrapper(FunctionDeclaration fun) {
+		correspondingFunWrapper = fun;
+	}
+
+	public FunctionDeclaration getCorrespondingFunctionWrapper() {
+		return correspondingFunWrapper;
+	}
 }
diff --git a/src/main/java/de/uni/bremen/monty/moco/codegeneration/CodeGenerator.java b/src/main/java/de/uni/bremen/monty/moco/codegeneration/CodeGenerator.java
@@ -398,6 +398,30 @@ public LLVMIdentifier<LLVMType> accessMember(CodeContext c, LLVMIdentifier<LLVMP
 		return result;
 	}
 
+	public LLVMIdentifier<LLVMType> accessClosureContextMember(CodeContext c, ClassDeclaration closureClass,
+	        VariableDeclaration varDecl, VariableAccess varAccess, TypeDeclaration variableType,
+	        LLVMIdentifier<LLVMPointer<LLVMType>> context) {
+
+		LLVMType contextType = LLVMTypeFactory.struct(nameMangler.mangleClass(closureClass) + "_closure_context");
+		LLVMIdentifier<LLVMType> contextLlvmIdentifier =
+		        accessMember(c, context, closureClass.getLastAttributeIndex(), contextType, false);
+		LLVMIdentifier<LLVMType> result =
+		        accessMember(
+		                c,
+		                llvmIdentifierFactory.pointerTo(contextLlvmIdentifier),
+		                varDecl.getAttributeIndex(),
+		                variableType,
+		                !varAccess.getLValue());
+		return result;
+	}
+
+	public LLVMIdentifier<LLVMType> accessClosureContextMember(CodeContext c, ClassDeclaration closureClass,
+	        VariableDeclaration varDecl, VariableAccess varAccess, TypeDeclaration variableType) {
+
+		LLVMIdentifier<LLVMPointer<LLVMType>> self = resolveLocalVarName("..ctx..", closureClass, false);
+		return accessClosureContextMember(c, closureClass, varDecl, varAccess, variableType, self);
+	}
+
 	public LLVMIdentifier<LLVMType> accessContextMember(CodeContext c, ClassDeclaration generatorClass,
 	        VariableDeclaration varDecl, VariableAccess varAccess, TypeDeclaration variableType) {
 
@@ -410,7 +434,7 @@ public LLVMIdentifier<LLVMType> accessContextMember(CodeContext c, ClassDeclarat
 		                (LLVMIdentifier<LLVMPointer<LLVMType>>) self,
 		                generatorClass.getLastAttributeIndex(),
 		                contextType,
-		                false); // TODO: richtig?
+		                false);
 		LLVMIdentifier<LLVMType> result =
 		        accessMember(
 		                c,