root/trunk/ProjectFortress/src/com/sun/fortress/interpreter/evaluator/BuildEnvironments.java

/*******************************************************************************
    Copyright 2008 Sun Microsystems, Inc.,
    4150 Network Circle, Santa Clara, California 95054, U.S.A.
    All rights reserved.

    U.S. Government Rights - Commercial software.
    Government users are subject to the Sun Microsystems, Inc. standard
    license agreement and applicable provisions of the FAR and its supplements.

    Use is subject to license terms.

    This distribution may include materials developed by third parties.

    Sun, Sun Microsystems, the Sun logo and Java are trademarks or registered
    trademarks of Sun Microsystems, Inc. in the U.S. and other countries.
 ******************************************************************************/

package com.sun.fortress.interpreter.evaluator;

import java.util.Iterator;
import java.util.List;
import edu.rice.cs.plt.tuple.Option;

import com.sun.fortress.useful.Useful;
import com.sun.fortress.exceptions.FortressException;
import com.sun.fortress.interpreter.env.FortressTests;
import com.sun.fortress.interpreter.env.LazilyEvaluatedCell;
import com.sun.fortress.interpreter.evaluator.types.FTraitOrObjectOrGeneric;
import com.sun.fortress.interpreter.evaluator.types.FType;
import com.sun.fortress.interpreter.evaluator.types.FTypeGeneric;
import com.sun.fortress.interpreter.evaluator.types.FTypeObject;
import com.sun.fortress.interpreter.evaluator.types.FTypeTop;
import com.sun.fortress.interpreter.evaluator.types.FTypeTrait;
import com.sun.fortress.interpreter.evaluator.types.SymbolicType;
import com.sun.fortress.interpreter.evaluator.types.SymbolicWhereType;
import com.sun.fortress.interpreter.evaluator.types.TypeGeneric;
import com.sun.fortress.interpreter.evaluator.values.Closure;
import com.sun.fortress.interpreter.evaluator.values.Constructor;
import com.sun.fortress.interpreter.evaluator.values.FGenericFunction;
import com.sun.fortress.interpreter.evaluator.values.FValue;
import com.sun.fortress.interpreter.evaluator.values.FVoid;
import com.sun.fortress.interpreter.evaluator.values.Fcn;
import com.sun.fortress.interpreter.evaluator.values.GenericConstructor;
import com.sun.fortress.interpreter.evaluator.values.GenericSingleton;
import com.sun.fortress.interpreter.evaluator.values.Simple_fcn;
import com.sun.fortress.interpreter.glue.WellKnownNames;
import com.sun.fortress.nodes.*;
import com.sun.fortress.nodes_util.Applicable;
import com.sun.fortress.nodes_util.ExprFactory;
import com.sun.fortress.nodes_util.NodeUtil;
import com.sun.fortress.useful.HasAt;

import static com.sun.fortress.exceptions.InterpreterBug.bug;
import static com.sun.fortress.exceptions.ProgramError.error;
import static com.sun.fortress.exceptions.ProgramError.errorMsg;

/**
 * This comment is not yet true; it is a goal.
 *
 * BuildEnvironments is a multiple-pass visitor pattern.
 *
 * The first pass, applied to a node that contains things (for example, a
 * component contains top-level declarations, a trait contains method
 * declarations) it creates entries for those things in the bindInto
 * environment.  In the top-level environment, traits and objects export
 * the names and definitions for the functional methods that they contain.
 *
 * The bindings created are not complete after the first pass.
 *
 * The second pass completes the type initialization. For contained things that
 * have internal structure (e.g., a trait within a top level list) this may
 * require a recursive visit, but with a newly allocated environment running its
 * first and second passes. This includes singleton object types.
 *
 * The third pass initializes functions and methods; these may depend on types.
 * The third pass must extract functional methods from traits and objects.
 *
 * The fourth pass performs value initialization. These may depend on functions.
 * This includes singleton object values.
 *
 * The evaluation order is slightly relaxed to make the interpreter tractable;
 * value cells (and variable cells?) are initialized with thunks. (How do we
 * thunk a singleton object?)
 *
 * It may be necessary to thunk the types as well; this is not yet entirely
 * clear because the type system is so complex. Because types already contain
 * references to their defining environment, this may proceed in an ad-hoc
 * fashion with lazy memoization.
 *
 * Note that not all passes are required in all contexts; only the top level has
 * the combination of types, functions, variables, and unordered access.
 * Different initializations are assigned to different (numbered) passes so that
 * environment building in some contexts can skip passes (for example, skip the
 * type pass in any non-top-level environment).
 *
 */
public class BuildEnvironments extends NodeAbstractVisitor<Boolean> {


     private int pass = 1;

    public void resetPass() {
        setPass(1);
    }

    public void assertPass(int p) {
        if (getPass() != p)
            bug("Expected pass " + p + " got pass " + getPass());
    }

    public void secondPass() {
        assertPass(1);
        setPass(2);
        // An environment must be blessed before it can be cloned.
        bindInto.bless();
    }

    public void thirdPass() {
        assertPass(2);
        setPass(3);
    }

    public void fourthPass() {
        assertPass(3);
        setPass(4);
    }

    public void visit(CompilationUnit n) {
        n.accept(this);
    }

    Environment containing;

    Environment bindInto;

    /**
     * Creates an environment builder that will inject bindings into 'within'.
     * The visit is suspended at generics (com.sun.fortress.interpreter.nodes
     * with type parameters) until they can be instantiated.
     */
    public BuildEnvironments(Environment within) {
        this.containing = within;
        this.bindInto = within;
    }

    protected BuildEnvironments(Environment within, Environment bind_into) {
        this.containing = within;
        this.bindInto = bind_into;
    }

    private BuildEnvironments(Environment within, int pass) {
        this.containing = within;
        this.bindInto = within;
        this.setPass(pass);
    }

    public Environment getEnvironment() {
        return containing;
    }

    static Closure instantiate(FGenericFunction x) {
        return null;
    }

    static Constructor instantiate(GenericConstructor x) {
        return null;
    }

    static FTypeTrait instantiate(TypeGeneric x) {
        return null;
    }




     protected static void doDefs(BuildEnvironments inner, List<? extends AbsDeclOrDecl> defs) {
        for (AbsDeclOrDecl def : defs) {
            def.accept(inner);
        }
    }

    protected void doDefs(List<? extends AbsDeclOrDecl> defs) {
        for (AbsDeclOrDecl def : defs) {
            def.accept(this);
        }
    }

//    /**
//     * Put the mappings into "into", but create closures against forTraitMethods.
//     *
//     * @param into
//     * @param forTraitMethods
//     * @param defs
//     * @param fields
//     */
//    private void doTraitMethodDefs(FTypeTrait ftt, Set<String> fields) {
//        BetterEnv into = ftt.getMembers();
//        BetterEnv forTraitMethods = ftt.getMethodExecutionEnv();
//        List<? extends AbsDeclOrDecl> defs = ftt.getASTmembers();
//
//        BuildTraitEnvironment inner = new BuildTraitEnvironment(into,
//                forTraitMethods, ftt, fields);
//
//        inner.doDefs1234(defs);
//
//    }
//
    public void doDefs1234(List<? extends AbsDeclOrDecl> defs) {
        doDefs(defs);
        doDefs234(defs);
    }

    public void doDefs234(List<? extends AbsDeclOrDecl> defs) {
        secondPass();
        doDefs(defs);
        thirdPass();
        doDefs(defs);
        fourthPass();
        doDefs(defs);
    }

    protected void guardedPutValue(Environment e, String name, FValue value,
            HasAt where) {
        guardedPutValue(e, name, value, null, where);

    }

    /**
     * Put a value, perhaps unconditionally depending on subtype's choice
     * @param e
     * @param name
     * @param value
     * @param ft
     */
    protected void putValue(Environment e, String name, FValue value, FType ft) {
        e.putVariable(name, value, ft);
    }

    /**
     * Put a value, perhaps unconditionally depending on subtype's choice
     */
    protected void putValue(Environment e, String name, FValue value) {
        e.putValue(name, value);
    }

    protected void guardedPutValue(Environment e, String name, FValue value,
            FType ft, HasAt where) {
        try {
            if (ft != null) {
                if (!ft.typeMatch(value)) {
                    error(where, e,
                            errorMsg("Type mismatch binding ", value, " (type ",
                                     value.type(), ") to ", name, " (type ",
                                     ft, ")"));
                }
                putValue(e, name, value, ft);
            } else {
                putValue(e, name, value);
            }
        } catch (FortressException pe) {
            throw pe.setContext(where,e);
        }
    }

    protected void guardedPutType(String name, FType type, HasAt where) {
        EvalType.guardedPutType(name, type, where, containing);
    }

    protected FValue newGenericClosure(Environment e, FnAbsDeclOrDecl x) {
        return new FGenericFunction(e, x);
    }



    private void forFnDef1(FnDef x) {
        List<StaticParam> optStaticParams = x.getStaticParams();
        String fname = NodeUtil.nameAsMethod(x);
        FValue cl;

        if (!optStaticParams.isEmpty()) {
            cl = newGenericClosure(containing, x);
        } else {
            // NOT GENERIC
            cl = newClosure(containing, x);

            // Search for test modifier -- can't we have a generic test modifier?
            List<Modifier> mods = x.getMods();
            if (!mods.isEmpty()) {
                for (Iterator<Modifier> i = mods.iterator(); i.hasNext();) {
                    Modifier m = i.next();
                    if (m instanceof ModifierTest) {
                        FortressTests.add((Closure) cl);
                        break;
                    }
                }
            }
        }
        // TODO this isn't right if it was a test function.
        // it belongs in a different namespace if it is.
        bindInto.putValue(fname, cl); // was "shadow"
        //LINKER putOrOverloadOrShadowGeneric(x, containing, name, cl);

    }

   private void forFnDef2(FnDef x) {
   }

   // Overridden in BuildTraitEnvironment
   protected void forFnDef3(FnDef x) {
       List<StaticParam> optStaticParams = x.getStaticParams();
       String fname = NodeUtil.nameAsMethod(x);
       Fcn fcn = (Fcn)containing.getValue(fname);
       fcn.finishInitializing();
   }

   private void forFnDef4(FnDef x) {
   }

 /*
     * (non-Javadoc)
     *
     * @see com.sun.fortress.interpreter.nodes.NodeVisitor#forFnDef(com.sun.fortress.interpreter.nodes.FnDef)
     */
    @Override
    public Boolean forFnDef(FnDef x) {
        switch (getPass()) {
        case 1: forFnDef1(x); break;
        case 2: forFnDef2(x); break;
        case 3: forFnDef3(x); break;
        case 4: forFnDef4(x); break;
        }
       return null;
    }

//    public void putOrOverloadOrShadow(HasAt x, BetterEnv e, IdOrOpOrAnonymousName name,
//            Simple_fcn cl) {
//        Fcn g = (Fcn) e.getValueNull(name.name());
//        if (g == null) {
//            putFunction(e, name, cl, x);
//
//            // This is delicate temporary code (below), and breaks the
//            // property that adding another layer of environment is an OK
//            // thing to do.
//        } else if (g.getWithin().equals(e)) {
//            // OVERLOADING
//            OverloadedFunction og;
//            if (g instanceof OverloadedFunction) {
//                og = (OverloadedFunction) g;
//                og.addOverload(cl);
//            } else if (g instanceof GenericMethodSet
//                    || g instanceof GenericMethod) {
//                error(x, e,
//                        "Cannot combine generic method and nongeneric method "
//                                + name.name() + " in an overloading");
//            } else if (g instanceof GenericFunctionSet
//                    || g instanceof FGenericFunction) {
//                error(x, e,
//                        "Cannot combine generic function and nongeneric function "
//                                + name.name() + " in an overloading");
//            } else {
//                og = new OverloadedFunction(name, e);
//                og.addOverload(cl);
//                og.addOverload((Simple_fcn) g);
//
//                assignFunction(e, name, og);
//            }
//        } else {
//            // SHADOWING
//            putFunction(e, name, cl, x);
//        }
//    }

//    /**
//     * @param x
//     * @param e
//     * @param name
//     * @param cl
//     */
//    private void putOrOverloadOrShadowGeneric(HasAt x, BetterEnv e,
//            IdOrOpOrAnonymousName name, FValue cl) {
//        FValue fv = e.getValueNull(name.name());
//        if (fv != null && !(fv instanceof Fcn)) {
//            error(x, e, "Generic not generic? " + name.name());
//        }
//        Fcn g = (Fcn) fv;
//        // Actually need to test for diff types of g.
//        if (g == null) {
//            putFunction(e, name, cl, x);
//        } else if (g.getWithin().equals(e)) {
//            // OVERLOADING
//            if (cl instanceof GenericMethod) {
//                GenericMethod clg = (GenericMethod) cl;
//                GenericMethodSet og;
//                if (g instanceof GenericMethodSet) {
//                    og = (GenericMethodSet) g;
//                    og.addOverload(clg);
//                } else if (g instanceof GenericMethod) {
//                    og = new GenericMethodSet(name, e);
//                    og.addOverload(clg);
//                    og.addOverload((GenericMethod) g);
//
//                    assignFunction(e, name, og);
//                } else {
//                    error(x, e, "Overload of generic method "
//                            + cl + " with non-generic/method " + g);
//                }
//            } else if (cl instanceof FGenericFunction) {
//                FGenericFunction clg = (FGenericFunction) cl;
//                GenericFunctionSet og;
//                if (g instanceof GenericFunctionSet) {
//                    og = (GenericFunctionSet) g;
//                    og.addOverload(clg);
//                } else if (g instanceof FGenericFunction) {
//                    og = new GenericFunctionSet(name, e);
//                    og.addOverload(clg);
//                    og.addOverload((FGenericFunction) g);
//
//                    assignFunction(e, name, og);
//                } else {
//                    error(x, e, "Overload of function method "
//                            + cl + " with non-generic/method " + g);
//                }
//            } else {
//                error(x, e,
//                        "Overload of generic, but not a method/function" + cl
//                                + " with generic/method " + g);
//
//            }
//        } else {
//            // SHADOWING
//            putFunction(e, name, cl, x);
//        }
//    }

    protected Simple_fcn newClosure(Environment e, Applicable x) {
        return new Closure(e, x);
    }

    private void putFunction(Environment e, IdOrOpOrAnonymousName name, FValue f, HasAt x) {
        String s = NodeUtil.nameString(name);
        guardedPutValue(e, s, f, x);
        e.noteName(s);
    }

    private static void assignFunction(Environment e, IdOrOpOrAnonymousName name, FValue f) {
        e.putValueRaw(NodeUtil.nameString(name), f);
    }

    /*
     * (non-Javadoc)
     *
     * @see com.sun.fortress.interpreter.nodes.NodeVisitor#forObjectDef(com.sun.fortress.interpreter.nodes.ObjectDecl)
     */
    @Override
    public Boolean forObjectDecl(ObjectDecl x) {
        switch (getPass()) {
        case 1: forObjectDecl1(x); break;
        case 2: forObjectDecl2(x); break;
        case 3: forObjectDecl3(x); break;
        case 4: forObjectDecl4(x); break;
        }
       return null;
    }
    protected void forObjectDecl1(ObjectDecl x) {
        // List<Modifier> mods;

        Environment e = containing;
        Id name = x.getName();

        List<StaticParam> staticParams = x.getStaticParams();
        Option<List<Param>> params = x.getParams();

        // List<Type> throws_;
        // List<WhereClause> where;
        // Contract contract;
        // List<Decl> defs = x.getDecls();
        String fname = NodeUtil.nameString(name);
        FTraitOrObjectOrGeneric ft;
        ft = staticParams.isEmpty() ?
                  new FTypeObject(fname, e, x, params, x.getDecls(), x)
                : new FTypeGeneric(e, x, x.getDecls(), x);

        // Need to check for overloaded constructor.

        guardedPutType(fname, ft, x);

        if (params.isSome()) {
            if (!staticParams.isEmpty()) {
                // A generic, not yet a constructor
                GenericConstructor gen = new GenericConstructor(e, x, name);
                guardedPutValue(containing, fname, gen, x);
            } else {
                // TODO need to deal with constructor overloading.

                // If parameters are present, it is really a constructor
                // BetterEnv interior = new SpineEnv(e, x);
                Constructor cl = new Constructor(containing, (FTypeObject) ft,
                        x);
                guardedPutValue(containing, fname, cl, x);
                // doDefs(interior, defs);
            }

        } else {
            if (!staticParams.isEmpty()) {
                // A parameterized singleton is a sort of generic value.
                // bug(x,"Generic singleton objects not yet implemented");
                makeGenericSingleton(x, e, name, fname, ft);

            } else {
                // It is a singleton; do not expose the constructor, do
                // visit the interior environment.
                // BetterEnv interior = new SpineEnv(e, x);

                // TODO - binding into "containing", or "bindInto"?

                Constructor cl = new Constructor(containing, (FTypeObject) ft,
                        x);
                guardedPutValue(containing, WellKnownNames.obfuscatedSingletonConstructorName(fname, x), cl, x);

                // Create a little expression to run the constructor.
                Expr init = ExprFactory.makeTightJuxt(x.getSpan(),
                      ExprFactory.makeVarRef(x.getSpan(), WellKnownNames.obfuscatedSingletonConstructorName(fname, x), 0),
                      ExprFactory.makeVoidLiteralExpr(x.getSpan()));
                FValue init_value = new LazilyEvaluatedCell(init, containing);
                putValue(bindInto, fname, init_value);

                // doDefs(interior, defs);
            }
        }

        scanForFunctionalMethodNames(ft, x.getDecls());

    }

    private void makeGenericSingleton(ObjectAbsDeclOrDecl x, Environment e, Id name,
            String fname, FTraitOrObjectOrGeneric ft) {
        GenericConstructor gen = new GenericConstructor(e, x, name);
        guardedPutValue(containing, WellKnownNames.obfuscatedSingletonConstructorName(fname, x), gen, x);
        guardedPutValue(containing, fname, new GenericSingleton(x,ft, gen), x);
    }

    public void scanForFunctionalMethodNames(
            FTraitOrObjectOrGeneric x,
            List<? extends AbsDeclOrDecl> defs) {
        scanForFunctionalMethodNames(x, defs, false);
    }

    public void scanForFunctionalMethodNames(FTraitOrObjectOrGeneric x,
            List<? extends AbsDeclOrDecl> defs, boolean bogus) {
        // This is probably going away.
        Environment topLevel = containing;
        if (getPass() == 1) {
            x.initializeFunctionalMethods();
        } else if (getPass() == 3) {
            x.finishFunctionalMethods();
        }

    }


     private void forObjectDecl2(ObjectDecl x) {

        Environment e = containing;
        Id name = x.getName();

        List<StaticParam> staticParams = x.getStaticParams();
        Option<List<Param>> params = x.getParams();

        String fname = NodeUtil.nameString(name);
        FType ft;

        if (params.isSome()) {
            if (!staticParams.isEmpty()) {
                // Do nothing.
            } else {
                FTypeObject fto = (FTypeObject) containing.getType(fname);
                FValue xxx = containing.getValue(fname);
                //Constructor cl = (Constructor) containing.getValue(fname);
                finishObjectTrait(x, fto);
            }
        } else {
            // If there are no parameters, it is a singleton.
            // Not clear we can evaluate it yet.
            if (!staticParams.isEmpty()) {
                // Do nothing.
            } else {
                FTypeObject fto = (FTypeObject) containing.getType(fname);

                finishObjectTrait(x, fto);
            }

        }

    }
    private void forObjectDecl3(ObjectDecl x) {
        Environment e = containing;
        Id name = x.getName();

        List<StaticParam> staticParams = x.getStaticParams();
        Option<List<Param>> params = x.getParams();

        String fname = NodeUtil.nameString(name);
        FTraitOrObjectOrGeneric ft = (FTraitOrObjectOrGeneric) containing.getType(fname);
        if (!staticParams.isEmpty()) {
            // Do nothing
        } else if (params.isSome()) {
            FTypeObject fto = (FTypeObject) ft;
            Fcn cl = (Fcn) containing.getValue(fname);
//                List<Parameter> fparams = EvalType.paramsToParameters(
//                        containing, params.unwrap());
//                cl.setParams(fparams);
            cl.finishInitializing();
        } else {
            Constructor cl = (Constructor) containing
                .getValue(WellKnownNames.obfuscatedSingletonConstructorName(fname, x));
            //  cl.setParams(Collections.<Parameter> emptyList());
            cl.finishInitializing();
        }
        scanForFunctionalMethodNames(ft, x.getDecls());
    }
    private void forObjectDecl4(ObjectDecl x) {

        Environment e = containing;
        Id name = x.getName();

        Option<List<Param>> params = x.getParams();

        String fname = NodeUtil.nameString(name);

        if (params.isSome()) {

        } else {
            // TODO - Blindly assuming a non-generic singleton.
            // TODO - Need to insert the name much, much, earlier; this is too late.

            FValue value = bindInto.getValue(fname);

//            Constructor cl = (Constructor) containing
//                    .getValue(obfuscated(fname));
//
//            guardedPutValue(containing, fname, cl.apply(java.util.Collections
//                    .<FValue> emptyList(), x, e), x);

        }
    }


    private String obfuscatedConstructorName(String fname) {
        // TODO Auto-generated method stub
        return "*1_" + fname;
    }

    /*
     * (non-Javadoc)
     *
     * @see com.sun.fortress.interpreter.nodes.NodeVisitor#forVarDef(com.sun.fortress.interpreter.nodes.VarDecl)
     */
    @Override
    public Boolean forVarDecl(VarDecl x) {
        switch (getPass()) {
        case 1:
            forVarDecl1(x);
            break;
        case 2:
            forVarDecl2(x);
            break;
        case 3:
            forVarDecl3(x);
            break;
        case 4:
            forVarDecl4(x);
            break;
        }
        return null;
    }

    private void forVarDecl1(VarDecl x) {
        List<LValueBind> lhs = x.getLhs();

        // List<Modifier> mods;
        // Id name = x.getName();
        // Option<Type> type = x.getType();
        Expr init = x.getInit();
        LValueBind lvb = lhs.get(0);

          Option<Type> type = lvb.getType();
          Id name = lvb.getName();
          String sname = NodeUtil.nameString(name);

          try {
              /* Ignore the type, until later */
              if (lvb.isMutable()) {
                  bindInto.putVariablePlaceholder(sname);
              } else {
                  FValue init_val = new LazilyEvaluatedCell(init, containing);
                  putValue(bindInto, sname, init_val);
              }
          } catch (FortressException pe) {
              throw pe.setContext(x,bindInto);
          }

//        int index = 0;

//        for (LValue lv : lhs) {
//            if (lv instanceof LValueBind) {
//                LValueBind lvb = (LValueBind) lv;
//                Option<Type> type = lvb.getType();
//                Id name = lvb.getName();
//                String sname = name.getName();
//
//                try {
//                    /* Ignore the type, until later */
//                    if (lvb.isMutable()) {
//                        bindInto.putVariablePlaceholder(sname);
//                    } else {
//                        FValue init_val;
//                        if (init instanceof ArgExpr) {
//                            init_val = new LazilyEvaluatedCell(
//                                      ((ArgExpr)init).getExprs().get(index++),
//                                      containing);
//                        } else {
//                            init_val = new LazilyEvaluatedCell(init, containing);
//                        }
//                        putValue(bindInto, sname, init_val);
//                    }
//                } catch (FortressError pe) {
//                    throw pe.setContext(x,bindInto);
//                }
//
//            } else {
//                bug(x, "Don't support arbitary LHS in Var decl yet");
//            }
//        }
    }

    private void forVarDecl2(VarDecl x) {

    }

    private void forVarDecl3(VarDecl x) {


    }

    private void forVarDecl4(VarDecl x) {

        List<LValueBind> lhs = x.getLhs();

        // List<Modifier> mods;
        // Id name = x.getName();
        // Option<Type> type = x.getType();
        Expr init = x.getInit();
        // int index = 0;
        LValueBind lvb = lhs.get(0);


         {
                Option<Type> type = lvb.getType();
                Id name = lvb.getName();
                String sname = NodeUtil.nameString(name);

                FType ft = type.isSome() ?
                        (new EvalType(containing)).evalType(type.unwrap())
                                : null;

                if (lvb.isMutable()) {
                    Expr rhs = init;

                    FValue value = (new Evaluator(containing)).eval(rhs);

                    // TODO When new environment are created, need to insert
                    // into containing AND bindInto

                    if (ft != null) {
                        if (!ft.typeMatch(value)) {
                            ft = error(x, bindInto,
                                    errorMsg("Type mismatch binding ", value, " (type ",
                                             value.type(), ") to ", name, " (type ",
                                             ft, ")"));
                        }
                    } else {
                        ft = FTypeTop.ONLY;
                    }
                    /* Finally, can finish this initialiation. */
                    bindInto.storeType(x, sname, ft);
                    bindInto.assignValue(x, sname, value);
                } else {
                    // Force evaluation, snap the link, check the type!
                    FValue value = bindInto.getValue(sname);
                    if (ft != null) {
                        if (!ft.typeMatch(value)) {
                            error(x, bindInto,
                                  errorMsg("Type mismatch binding ", value, " (type ",
                                  value.type(), ") to ", name, " (type ",
                                  ft, ")"));
                        }
        &nb