(refs #7746) Fixed applications with intermediate effects

[simantics/platform.git] / bundles / org.simantics.scl.compiler / src / org / simantics / scl / compiler / elaboration / expressions / EApply.java

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 5d915a98dce93b2ac88e2476effaed460e2d25ba..7f50d730b9f0d536fc91f6dfa439f8ccebc43fcd 100644 (file)
--- 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,7 +29,6 @@ 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;
 
@@ -220,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
@@ -236,40 +235,50 @@ 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) {
+                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]).checkIgnoredType(context);
-        inferType(context, true);
+        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() {