X-Git-Url: https://gerrit.simantics.org/r/gitweb?a=blobdiff_plain;f=bundles%2Forg.simantics.scl.compiler%2Fsrc%2Forg%2Fsimantics%2Fscl%2Fcompiler%2Felaboration%2Fexpressions%2FEApply.java;h=06ff05c18bf4aec3cb60325734daa382e2544a92;hb=ae3bfd23d4b7c6bd581ad1238e25bd4f513b2643;hp=14366a4c9a366ea4e84711e20a319a79ae1998d4;hpb=6dfe20b0f514b91337fcac4de0267ffd8268be07;p=simantics%2Fplatform.git

diff --git a/bundles/org.simantics.scl.compiler/src/org/simantics/scl/compiler/elaboration/expressions/EApply.java b/bundles/org.simantics.scl.compiler/src/org/simantics/scl/compiler/elaboration/expressions/EApply.java
index 14366a4c9..06ff05c18 100644
--- a/bundles/org.simantics.scl.compiler/src/org/simantics/scl/compiler/elaboration/expressions/EApply.java
+++ b/bundles/org.simantics.scl.compiler/src/org/simantics/scl/compiler/elaboration/expressions/EApply.java
@@ -1,6 +1,7 @@
 package org.simantics.scl.compiler.elaboration.expressions;
 
 import java.util.ArrayList;
+import java.util.Arrays;
 
 import org.simantics.scl.compiler.common.names.Name;
 import org.simantics.scl.compiler.common.names.Names;
@@ -28,13 +29,9 @@ import org.simantics.scl.compiler.types.TFun;
 import org.simantics.scl.compiler.types.Type;
 import org.simantics.scl.compiler.types.Types;
 import org.simantics.scl.compiler.types.exceptions.MatchException;
-import org.simantics.scl.compiler.types.exceptions.UnificationException;
 import org.simantics.scl.compiler.types.kinds.Kinds;
 import org.simantics.scl.compiler.types.util.MultiFunction;
 
-import gnu.trove.map.hash.TObjectIntHashMap;
-import gnu.trove.set.hash.TIntHashSet;
-
 public class EApply extends Expression {
     public Expression function;
     public Expression[] parameters;
@@ -74,15 +71,9 @@ public class EApply extends Expression {
     public Expression[] getParameters() {
         return parameters;
     }
-    
-    public void collectVars(TObjectIntHashMap<Variable> allVars, TIntHashSet vars) {
-        function.collectVars(allVars, vars);
-        for(Expression parameter : parameters)
-            parameter.collectVars(allVars, vars);
-    }
-	
-	@Override
-	protected void updateType() throws MatchException {
+
+    @Override
+    protected void updateType() throws MatchException {
         MultiFunction mfun = Types.matchFunction(function.getType(), parameters.length);
         /*for(int i=0;i<parameters.length;++i)
             if(!Types.equals(parameters[i].getType(), mfun.parameterTypes[i]))
@@ -229,14 +220,13 @@ public class EApply extends Expression {
         return new IApply(function.toIExpression(target), parametersI);
     }
     
-    private void inferType(TypingContext context, boolean ignoreResult) {
+    private Expression inferType(TypingContext context, boolean ignoreResult) {
         function = function.inferType(context);
         function = context.instantiate(function);
-        MultiFunction mfun;
-        try {
-            mfun = Types.unifyFunction(function.getType(), parameters.length);
-        } catch (UnificationException e) {
-            int arity = Types.getArity(function.getType());
+        Type functionType = function.getType();
+        
+        int arity = Types.getMaxArity(functionType);
+        if(arity < parameters.length) {
             if(arity == 0)
                 context.getErrorLog().log(location, "Application of non-function.");
             else
@@ -245,40 +235,56 @@ public class EApply extends Expression {
             setType(Types.metaVar(Kinds.STAR));
             for(int i=0;i<parameters.length;++i)
                 parameters[i] = parameters[i].inferType(context);
-            return;
-        }
-        if((ignoreResult && Skeletons.canonicalSkeleton(mfun.returnType) instanceof TFun &&
-                Types.canonical(mfun.effect) == Types.NO_EFFECTS) ||
-                (context.isInPattern() && Skeletons.canonicalSkeleton(mfun.returnType) instanceof TFun)) {
-            context.getErrorLog().log(location, "The function is applied with too few parameters.");
+            return this;
         }
         
-        // Check parameter types
-        for(int i=0;i<parameters.length;++i)
-            parameters[i] = parameters[i].checkType(context, mfun.parameterTypes[i]);
+        EApply current = this;
+        while(true) {
+            MultiFunction mfun = Types.unifyFunction2(functionType, current.parameters.length);
+            int marity = mfun.parameterTypes.length;
+            for(int i=0;i<marity;++i)
+                current.parameters[i] = current.parameters[i].checkType(context, mfun.parameterTypes[i]);
+            current.effect = mfun.effect;
+            context.declareEffect(location, mfun.effect);
+            current.setType(mfun.returnType);
 
-        effect = mfun.effect;
-        
-        context.declareEffect(location, mfun.effect);
-        setType(mfun.returnType);
+            if(marity < current.parameters.length) {
+                if (marity == 0) {
+                    // Cannot eat away any more parameters
+                    context.getErrorLog().log(location, "Application of non-function");
+                    return current;
+                }
+                
+                Expression[] missingParameters = Arrays.copyOfRange(current.parameters, marity, current.parameters.length);
+                functionType = mfun.returnType;
+                current.parameters = Arrays.copyOf(current.parameters, marity);
+                current = new EApply(current, missingParameters);
+            }
+            else {
+                if((ignoreResult && mfun.effect == Types.NO_EFFECTS && Skeletons.canonicalSkeleton(mfun.returnType) instanceof TFun) ||
+                        (context.isInPattern() && Skeletons.canonicalSkeleton(mfun.returnType) instanceof TFun)) {
+                    context.getErrorLog().log(location, "The function is applied with too few parameters.");
+                }
+                return current;
+            }
+        }
     }
     
     @Override
     public Expression inferType(TypingContext context) {
         if(parameters.length == 2 && function instanceof EConstant && ((EConstant)function).value.getName() == Names.Prelude_dollar)
             return new EApply(location, parameters[0], parameters[1]).inferType(context);
-        inferType(context, false);
-        return this;
+        return inferType(context, false);
     }
     
     @Override
     public Expression checkIgnoredType(TypingContext context) {
         if(parameters.length == 2 && function instanceof EConstant && ((EConstant)function).value.getName() == Names.Prelude_dollar)
-            return new EApply(location, parameters[0], parameters[1]).inferType(context);
-        inferType(context, true);
+            return new EApply(location, parameters[0], parameters[1]).checkIgnoredType(context);
+        Expression expression = inferType(context, true);
         if(Types.canonical(getType()) != Types.UNIT)
-            return new ESimpleLet(location, null, this, new ELiteral(NoRepConstant.PUNIT));
-        return this;
+            expression = new ESimpleLet(location, null, expression, new ELiteral(NoRepConstant.PUNIT));
+        return expression;
     }
     
     public Type getLocalEffect() {