// Return false if the inference is illegal. Currently this only happens if the var is reassigned
  // to incompatible
  // type inside the loop.
  public boolean add(VariableExpression ve, ClassNode type) {
    if (defVars == null) defVars = FHashMap.emptyMap;

    if (ve.getAccessedVariable() != null) {
      defVars = defVars.put(ve.getAccessedVariable(), type);
      //            dumpMap(ve);
    } else {
      boolean done = false;
      for (Map.Entry<Variable, ClassNode> variable : defVars.entrySet()) {
        if (variable.getKey().getName().equals(ve.getName())) {
          defVars = defVars.put(variable.getKey(), type);
          //                    dumpMap(ve);
          done = true;
          break;
        }
      }

      if (!done) {
        defVars = defVars.put(ve, type);
        //                dumpMap(ve);
      }
    }

    if (parentScopeInference != null && parentScopeInference.defVars != null) {
      final ClassNode oldType = parentScopeInference.defVars.get(ve.getAccessedVariable());
      if (oldType != null) {
        if (!TypeUtil.isDirectlyAssignableFrom(oldType, type)) {
          return false;
        }
      }
    }

    return true;
  }
 public void jumpFrom(LocalVarInferenceTypes cur) {
   if (!visited) {
     if (defVars == null) {
       // we are 1st time here - just init
       if (cur.defVars != null) defVars = cur.defVars;
       else defVars = FHashMap.emptyMap;
     } else {
       // we were here already, so we need to merge
       if (cur.defVars != null)
         for (Map.Entry<Variable, ClassNode> e : cur.defVars.entrySet()) {
           final ClassNode oldType = defVars.get(e.getKey());
           if (oldType != null) {
             final ClassNode newType = TypeUtil.commonType(oldType, e.getValue());
             if (newType != oldType) defVars = defVars.put(e.getKey(), newType);
           }
         }
     }
   } else {
     // jump back - all is checked, nothing too be done at this point.
   }
 }