Dependency checker refactoring

teavm-classlib/src/main/java/org/teavm/classlib/java/lang/CharacterNativeGenerator.java

@@ -21,7 +21,7 @@ import org.teavm.classlib.impl.unicode.UnicodeSupport;
 import org.teavm.codegen.SourceWriter;
 import org.teavm.dependency.DependencyChecker;
 import org.teavm.dependency.DependencyPlugin;
-import org.teavm.dependency.MethodGraph;
+import org.teavm.dependency.MethodDependency;
 import org.teavm.javascript.ni.Generator;
 import org.teavm.javascript.ni.GeneratorContext;
 import org.teavm.model.MethodReference;
@@ -49,7 +49,7 @@ public class CharacterNativeGenerator implements Generator, DependencyPlugin {
     }
 
     @Override
-    public void methodAchieved(DependencyChecker checker, MethodGraph graph) {
+    public void methodAchieved(DependencyChecker checker, MethodDependency graph) {
         switch (graph.getReference().getName()) {
             case "obtainDigitMapping":
                 achieveObtainDigitMapping(graph);
@@ -72,7 +72,7 @@ public class CharacterNativeGenerator implements Generator, DependencyPlugin {
                 .append("\");").softNewLine();
     }
 
-    private void achieveObtainDigitMapping(MethodGraph graph) {
+    private void achieveObtainDigitMapping(MethodDependency graph) {
         graph.getResult().propagate("java.lang.String");
     }
 }

teavm-classlib/src/main/java/org/teavm/classlib/java/lang/ObjectNativeGenerator.java

@@ -19,7 +19,7 @@ import java.io.IOException;
 import org.teavm.codegen.SourceWriter;
 import org.teavm.dependency.DependencyChecker;
 import org.teavm.dependency.DependencyPlugin;
-import org.teavm.dependency.MethodGraph;
+import org.teavm.dependency.MethodDependency;
 import org.teavm.javascript.ni.Generator;
 import org.teavm.javascript.ni.GeneratorContext;
 import org.teavm.javascript.ni.Injector;
@@ -40,6 +40,7 @@ public class ObjectNativeGenerator implements Generator, Injector, DependencyPlu
                 generateInit(context, writer);
                 break;
             case "hashCode":
+            case "identity":
                 generateHashCode(context, writer);
                 break;
             case "clone":
@@ -61,7 +62,7 @@ public class ObjectNativeGenerator implements Generator, Injector, DependencyPlu
     }
 
     @Override
-    public void methodAchieved(DependencyChecker checker, MethodGraph graph) {
+    public void methodAchieved(DependencyChecker checker, MethodDependency graph) {
         switch (graph.getReference().getName()) {
             case "clone":
                 achieveClone(graph);
@@ -86,7 +87,7 @@ public class ObjectNativeGenerator implements Generator, Injector, DependencyPlu
         writer.append(".constructor)");
     }
 
-    private void achieveGetClass(DependencyChecker checker, MethodGraph graph) {
+    private void achieveGetClass(DependencyChecker checker, MethodDependency graph) {
         String classClass = "java.lang.Class";
         MethodReference initMethod = new MethodReference(classClass, new MethodDescriptor("createNew",
                 ValueType.object(classClass)));
@@ -107,7 +108,7 @@ public class ObjectNativeGenerator implements Generator, Injector, DependencyPlu
         writer.append("return copy;").softNewLine();
     }
 
-    private void achieveClone(MethodGraph graph) {
+    private void achieveClone(MethodDependency graph) {
         graph.getVariable(0).connect(graph.getResult());
     }
 
@@ -115,7 +116,7 @@ public class ObjectNativeGenerator implements Generator, Injector, DependencyPlu
         context.writeExpr(context.getArgument(0));
     }
 
-    private void achieveWrap(MethodGraph graph) {
+    private void achieveWrap(MethodDependency graph) {
         graph.getVariable(1).connect(graph.getResult());
     }
 }

teavm-classlib/src/main/java/org/teavm/classlib/java/lang/SystemNativeGenerator.java

@@ -20,7 +20,7 @@ import org.teavm.codegen.SourceWriter;
 import org.teavm.dependency.DependencyChecker;
 import org.teavm.dependency.DependencyNode;
 import org.teavm.dependency.DependencyPlugin;
-import org.teavm.dependency.MethodGraph;
+import org.teavm.dependency.MethodDependency;
 import org.teavm.javascript.ni.Generator;
 import org.teavm.javascript.ni.GeneratorContext;
 import org.teavm.model.MethodReference;
@@ -43,7 +43,7 @@ public class SystemNativeGenerator implements Generator, DependencyPlugin {
     }
 
     @Override
-    public void methodAchieved(DependencyChecker checker, MethodGraph graph) {
+    public void methodAchieved(DependencyChecker checker, MethodDependency graph) {
         switch (graph.getReference().getName()) {
             case "doArrayCopy":
                 achieveArrayCopy(graph);
@@ -66,7 +66,7 @@ public class SystemNativeGenerator implements Generator, DependencyPlugin {
         writer.append("return Long_fromNumber(new Date().getTime());").softNewLine();
     }
 
-    private void achieveArrayCopy(MethodGraph graph) {
+    private void achieveArrayCopy(MethodDependency graph) {
         DependencyNode src = graph.getVariable(1);
         DependencyNode dest = graph.getVariable(3);
         src.getArrayItem().connect(dest.getArrayItem());

teavm-classlib/src/main/java/org/teavm/classlib/java/lang/TClass.java

@@ -23,7 +23,7 @@ import org.teavm.javascript.ni.InjectedBy;
  * @author Alexey Andreev <konsoletyper@gmail.com>
  */
 public class TClass<T> extends TObject {
-    String name;
+    TString name;
     boolean primitive;
     boolean array;
     private TClass<?> componentType;
@@ -39,7 +39,7 @@ public class TClass<T> extends TObject {
     @InjectedBy(ClassNativeGenerator.class)
     public native boolean isAssignableFrom(TClass<?> obj);
 
-    public String getName() {
+    public TString getName() {
         return name;
     }
 

teavm-classlib/src/main/java/org/teavm/classlib/java/lang/TObject.java

@@ -49,7 +49,12 @@ public class TObject {
     }
 
     @Rename("toString")
-    public native TString toString0();
+    public TString toString0() {
+        return TString.wrap(getClass().getName() + "@" + identity());
+    }
+
+    @GeneratedBy(ObjectNativeGenerator.class)
+    native int identity();
 
     @Override
     @GeneratedBy(ObjectNativeGenerator.class)

teavm-classlib/src/main/java/org/teavm/classlib/java/lang/reflect/ArrayNativeGenerator.java

@@ -20,7 +20,7 @@ import org.teavm.codegen.SourceWriter;
 import org.teavm.dependency.DependencyChecker;
 import org.teavm.dependency.DependencyConsumer;
 import org.teavm.dependency.DependencyPlugin;
-import org.teavm.dependency.MethodGraph;
+import org.teavm.dependency.MethodDependency;
 import org.teavm.javascript.ni.Generator;
 import org.teavm.javascript.ni.GeneratorContext;
 import org.teavm.model.MethodDescriptor;
@@ -33,7 +33,7 @@ import org.teavm.model.ValueType;
  */
 public class ArrayNativeGenerator implements Generator, DependencyPlugin {
     @Override
-    public void methodAchieved(DependencyChecker checker, MethodGraph graph) {
+    public void methodAchieved(DependencyChecker checker, MethodDependency graph) {
         if (graph.getReference().getName().equals("getLength")) {
             achieveGetLength(checker, graph);
         }
@@ -59,7 +59,7 @@ public class ArrayNativeGenerator implements Generator, DependencyPlugin {
         writer.append("return " + array + ".data.length;").softNewLine();
     }
 
-    private void achieveGetLength(final DependencyChecker checker, final MethodGraph graph) {
+    private void achieveGetLength(final DependencyChecker checker, final MethodDependency graph) {
         graph.getVariable(1).addConsumer(new DependencyConsumer() {
             @Override public void consume(String type) {
                 if (!type.startsWith("[")) {

teavm-core/src/main/java/org/teavm/dependency/DependencyChecker.java

@@ -29,14 +29,16 @@ import org.teavm.model.*;
 public class DependencyChecker implements DependencyInformation {
     private static Object dummyValue = new Object();
     static final boolean shouldLog = System.getProperty("org.teavm.logDependencies", "false").equals("true");
-    private ClassHolderSource classSource;
+    private ClassReaderSource classSource;
     private ClassLoader classLoader;
     private FiniteExecutor executor;
+    private Mapper<MethodReference, MethodReader> methodReaderCache;
+    private Mapper<FieldReference, FieldReader> fieldReaderCache;
     private ConcurrentMap<MethodReference, Object> abstractMethods = new ConcurrentHashMap<>();
     private ConcurrentMap<MethodReference, DependencyStack> stacks = new ConcurrentHashMap<>();
     private ConcurrentMap<FieldReference, DependencyStack> fieldStacks = new ConcurrentHashMap<>();
     private ConcurrentMap<String, DependencyStack> classStacks = new ConcurrentHashMap<>();
-    private ConcurrentCachedMapper<MethodReference, MethodGraph> methodCache;
+    private ConcurrentCachedMapper<MethodReference, MethodDependency> methodCache;
     private ConcurrentCachedMapper<FieldReference, DependencyNode> fieldCache;
     private ConcurrentMap<String, Object> achievableClasses = new ConcurrentHashMap<>();
     private ConcurrentMap<String, Object> initializedClasses = new ConcurrentHashMap<>();
@@ -45,28 +47,48 @@ public class DependencyChecker implements DependencyInformation {
     ConcurrentMap<String, DependencyStack> missingClasses = new ConcurrentHashMap<>();
     ConcurrentMap<FieldReference, DependencyStack> missingFields = new ConcurrentHashMap<>();
 
-    public DependencyChecker(ClassHolderSource classSource, ClassLoader classLoader) {
+    public DependencyChecker(ClassReaderSource classSource, ClassLoader classLoader) {
         this(classSource, classLoader, new SimpleFiniteExecutor());
     }
 
-    public DependencyChecker(ClassHolderSource classSource, ClassLoader classLoader, FiniteExecutor executor) {
+    public DependencyChecker(ClassReaderSource classSource, ClassLoader classLoader, FiniteExecutor executor) {
         this.classSource = classSource;
         this.classLoader = classLoader;
         this.executor = executor;
-        methodCache = new ConcurrentCachedMapper<>(new Mapper<MethodReference, MethodGraph>() {
+        methodReaderCache = new ConcurrentCachedMapper<>(new Mapper<MethodReference, MethodReader>() {
-            @Override public MethodGraph map(MethodReference preimage) {
+            @Override public MethodReader map(MethodReference preimage) {
-                return createMethodGraph(preimage, stacks.get(preimage));
+                return findMethodReader(preimage);
+            }
+        });
+        fieldReaderCache = new ConcurrentCachedMapper<>(new Mapper<FieldReference, FieldReader>() {
+            @Override public FieldReader map(FieldReference preimage) {
+                return findFieldReader(preimage);
+            }
+        });
+        methodCache = new ConcurrentCachedMapper<>(new Mapper<MethodReference, MethodDependency>() {
+            @Override public MethodDependency map(MethodReference preimage) {
+                MethodReader method = methodReaderCache.map(preimage);
+                if (method != null && !method.getReference().equals(preimage)) {
+                    stacks.put(method.getReference(), stacks.get(preimage));
+                    return methodCache.map(method.getReference());
+                }
+                return createMethodDep(preimage, method, stacks.get(preimage));
             }
         });
         fieldCache = new ConcurrentCachedMapper<>(new Mapper<FieldReference, DependencyNode>() {
             @Override public DependencyNode map(FieldReference preimage) {
-                return createFieldNode(preimage, fieldStacks.get(preimage));
+                FieldReader field = fieldReaderCache.map(preimage);
+                if (field != null && !field.getReference().equals(preimage)) {
+                    fieldStacks.put(field.getReference(), fieldStacks.get(preimage));
+                    return fieldCache.map(field.getReference());
+                }
+                return createFieldNode(preimage, field, fieldStacks.get(preimage));
             }
         });
         methodCache.addKeyListener(new KeyListener<MethodReference>() {
             @Override public void keyAdded(MethodReference key) {
-                MethodGraph graph = methodCache.getKnown(key);
+                MethodDependency graph = methodCache.getKnown(key);
-                if (!missingMethods.containsKey(key) && !missingClasses.containsKey(key.getClassName())) {
+                if (!graph.isMissing()) {
                     for (DependencyListener listener : listeners) {
                         listener.methodAchieved(DependencyChecker.this, graph);
                     }
@@ -90,7 +112,7 @@ public class DependencyChecker implements DependencyInformation {
         return new DependencyNode(this);
     }
 
-    public ClassHolderSource getClassSource() {
+    public ClassReaderSource getClassSource() {
         return classSource;
     }
 
@@ -109,7 +131,7 @@ public class DependencyChecker implements DependencyInformation {
         if (parameters.length != argumentTypes.length) {
             throw new IllegalArgumentException("argumentTypes length does not match the number of method's arguments");
         }
-        MethodGraph graph = attachMethodGraph(methodRef, DependencyStack.ROOT);
+        MethodDependency graph = linkMethod(methodRef, DependencyStack.ROOT);
         DependencyNode[] varNodes = graph.getVariables();
         varNodes[0].propagate(methodRef.getClassName());
         for (int i = 0; i < argumentTypes.length; ++i) {
@@ -140,7 +162,7 @@ public class DependencyChecker implements DependencyInformation {
         return result;
     }
 
-    public MethodGraph attachMethodGraph(MethodReference methodRef, DependencyStack stack) {
+    public MethodDependency linkMethod(MethodReference methodRef, DependencyStack stack) {
         stacks.putIfAbsent(methodRef, stack);
         return methodCache.map(methodRef);
     }
@@ -154,14 +176,14 @@ public class DependencyChecker implements DependencyInformation {
             }
             achieveClass(className, stack);
             achieveInterfaces(className, stack);
-            ClassHolder cls = classSource.get(className);
+            ClassReader cls = classSource.get(className);
             if (cls == null) {
                 missingClasses.put(className, stack);
                 return;
             }
             if (cls.getMethod(clinitDesc) != null) {
                 MethodReference methodRef = new MethodReference(className, clinitDesc);
-                attachMethodGraph(methodRef, new DependencyStack(methodRef, stack));
+                linkMethod(methodRef, new DependencyStack(methodRef, stack));
             }
             className = cls.getParent();
         }
@@ -169,7 +191,7 @@ public class DependencyChecker implements DependencyInformation {
 
     private void achieveInterfaces(String className, DependencyStack stack) {
         classStacks.putIfAbsent(className, stack);
-        ClassHolder cls = classSource.get(className);
+        ClassReader cls = classSource.get(className);
         if (cls == null) {
             missingClasses.put(className, stack);
             return;
@@ -181,29 +203,44 @@ public class DependencyChecker implements DependencyInformation {
         }
     }
 
-    private MethodGraph createMethodGraph(final MethodReference methodRef, DependencyStack stack) {
+    private MethodReader findMethodReader(MethodReference methodRef) {
+        String clsName = methodRef.getClassName();
+        MethodDescriptor desc = methodRef.getDescriptor();
+        while (clsName != null) {
+            ClassReader cls = classSource.get(clsName);
+            if (cls == null) {
+                return null;
+            }
+            MethodReader method = cls.getMethod(desc);
+            if (method != null) {
+                return method;
+            }
+            clsName = cls.getParent();
+        }
+        return null;
+    }
+
+    private FieldReader findFieldReader(FieldReference fieldRef) {
+        String clsName = fieldRef.getClassName();
+        String name = fieldRef.getFieldName();
+        while (clsName != null) {
+            ClassReader cls = classSource.get(clsName);
+            if (cls == null) {
+                return null;
+            }
+            FieldReader field = cls.getField(name);
+            if (field != null) {
+                return field;
+            }
+            clsName = cls.getParent();
+        }
+        return null;
+    }
+
+    private MethodDependency createMethodDep(MethodReference methodRef, MethodReader method, DependencyStack stack) {
         if (stack == null) {
             stack = DependencyStack.ROOT;
         }
-        initClass(methodRef.getClassName(), stack);
-        ClassHolder cls = classSource.get(methodRef.getClassName());
-        MethodHolder method;
-        if (cls == null) {
-            missingClasses.put(methodRef.getClassName(), stack);
-            method = null;
-        } else {
-            method = cls.getMethod(methodRef.getDescriptor());
-            if (method == null) {
-                while (cls != null) {
-                    method = cls.getMethod(methodRef.getDescriptor());
-                    if (method != null) {
-                        return attachMethodGraph(method.getReference(), stack);
-                    }
-                    cls = cls.getParent() != null ? classSource.get(cls.getParent()) : null;
-                }
-                missingMethods.put(methodRef, stack);
-            }
-        }
         ValueType[] arguments = methodRef.getParameterTypes();
         int paramCount = arguments.length + 1;
         int varCount = Math.max(paramCount, method != null ? method.getProgram().variableCount() : 0);
@@ -224,17 +261,23 @@ public class DependencyChecker implements DependencyInformation {
             }
         }
         stack = new DependencyStack(methodRef, stack);
-        final MethodGraph graph = new MethodGraph(parameterNodes, paramCount, resultNode, stack, methodRef);
+        final MethodDependency dep = new MethodDependency(parameterNodes, paramCount, resultNode, stack, method,
+                methodRef);
         if (method != null) {
-            final MethodHolder currentMethod = method;
+            final MethodReader currentMethod = method;
             executor.execute(new Runnable() {
                 @Override public void run() {
                     DependencyGraphBuilder graphBuilder = new DependencyGraphBuilder(DependencyChecker.this);
-                    graphBuilder.buildGraph(currentMethod, graph);
+                    graphBuilder.buildGraph(currentMethod, dep);
                 }
             });
+        } else {
+            missingMethods.putIfAbsent(methodRef, stack);
         }
-        return graph;
+        if (method != null) {
+            initClass(methodRef.getClassName(), stack);
+        }
+        return dep;
     }
 
     public boolean isMethodAchievable(MethodReference methodRef) {
@@ -260,7 +303,7 @@ public class DependencyChecker implements DependencyInformation {
         return new HashSet<>(achievableClasses.keySet());
     }
 
-    public DependencyNode attachFieldNode(FieldReference fieldRef, DependencyStack stack) {
+    public DependencyNode linkField(FieldReference fieldRef, DependencyStack stack) {
         fieldStacks.putIfAbsent(fieldRef, stack);
         return fieldCache.map(fieldRef);
     }
@@ -270,38 +313,27 @@ public class DependencyChecker implements DependencyInformation {
         return fieldCache.getKnown(fieldRef);
     }
 
-    private DependencyNode createFieldNode(FieldReference fieldRef, DependencyStack stack) {
+    private DependencyNode createFieldNode(FieldReference fieldRef, FieldReader field, DependencyStack stack) {
-        initClass(fieldRef.getClassName(), stack);
-        ClassHolder cls = classSource.get(fieldRef.getClassName());
-        if (cls == null) {
-            missingClasses.put(fieldRef.getClassName(), stack);
-        } else {
-            FieldHolder field = cls.getField(fieldRef.getFieldName());
-            if (field == null) {
-                while (cls != null) {
-                    field = cls.getField(fieldRef.getFieldName());
-                    if (field != null) {
-                        return attachFieldNode(new FieldReference(cls.getName(), fieldRef.getFieldName()), stack);
-                    }
-                    cls = cls.getParent() != null ? classSource.get(cls.getParent()) : null;
-                }
-                missingFields.put(fieldRef, stack);
-            }
-        }
         DependencyNode node = new DependencyNode(this);
+        if (field == null) {
+            missingFields.putIfAbsent(fieldRef, stack);
+        }
         if (shouldLog) {
             node.setTag(fieldRef.getClassName() + "#" + fieldRef.getFieldName());
         }
+        if (field != null) {
+            initClass(fieldRef.getClassName(), stack);
+        }
         return node;
     }
 
-    private void activateDependencyPlugin(MethodGraph graph) {
+    private void activateDependencyPlugin(MethodDependency graph) {
         MethodReference methodRef = graph.getReference();
-        ClassHolder cls = classSource.get(methodRef.getClassName());
+        ClassReader cls = classSource.get(methodRef.getClassName());
         if (cls == null) {
             return;
         }
-        MethodHolder method = cls.getMethod(methodRef.getDescriptor());
+        MethodReader method = cls.getMethod(methodRef.getDescriptor());
         if (method == null) {
             return;
         }
@@ -331,11 +363,11 @@ public class DependencyChecker implements DependencyInformation {
         if (abstractMethods.putIfAbsent(methodRef, methodRef) == null) {
             String className = methodRef.getClassName();
             while (className != null) {
-                ClassHolder cls = classSource.get(className);
+                ClassReader cls = classSource.get(className);
                 if (cls == null) {
                     return;
                 }
-                MethodHolder method = cls.getMethod(methodRef.getDescriptor());
+                MethodReader method = cls.getMethod(methodRef.getDescriptor());
                 if (method != null) {
                     abstractMethods.put(methodRef, methodRef);
                     return;
@@ -345,7 +377,7 @@ public class DependencyChecker implements DependencyInformation {
         }
     }
 
-    public ListableClassHolderSource cutUnachievableClasses() {
+    public ListableClassHolderSource cutUnachievableClasses(ClassHolderSource classSource) {
         MutableClassHolderSource cutClasses = new MutableClassHolderSource();
         for (String className : achievableClasses.keySet()) {
             ClassHolder classHolder = classSource.get(className);

teavm-core/src/main/java/org/teavm/dependency/DependencyGraphBuilder.java

@@ -16,6 +16,8 @@
 package org.teavm.dependency;
 
 import java.util.List;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentMap;
 import org.teavm.model.*;
 import org.teavm.model.instructions.*;
 import org.teavm.model.util.ListingBuilder;
@@ -28,15 +30,15 @@ class DependencyGraphBuilder {
     private DependencyChecker dependencyChecker;
     private DependencyNode[] nodes;
     private DependencyNode resultNode;
-    private Program program;
+    private ProgramReader program;
     private DependencyStack callerStack;
 
     public DependencyGraphBuilder(DependencyChecker dependencyChecker) {
         this.dependencyChecker = dependencyChecker;
     }
 
-    public void buildGraph(MethodHolder method, MethodGraph graph) {
+    public void buildGraph(MethodReader method, MethodDependency graph) {
-        if (method.getProgram().basicBlockCount() == 0) {
+        if (method.getProgram() == null || method.getProgram().basicBlockCount() == 0) {
             return;
         }
         callerStack = graph.getStack();
@@ -48,12 +50,10 @@ class DependencyGraphBuilder {
         resultNode = graph.getResult();
         nodes = graph.getVariables();
         for (int i = 0; i < program.basicBlockCount(); ++i) {
-            BasicBlock block = program.basicBlockAt(i);
+            BasicBlockReader block = program.basicBlockAt(i);
-            for (Instruction insn : block.getInstructions()) {
+            block.readAllInstructions(reader);
-                insn.acceptVisitor(visitor);
+            for (PhiReader phi : block.readPhis()) {
-            }
+                for (IncomingReader incoming : phi.readIncomings()) {
-            for (Phi phi : block.getPhis()) {
-                for (Incoming incoming : phi.getIncomings()) {
                     nodes[incoming.getValue().getIndex()].connect(nodes[phi.getReceiver().getIndex()]);
                 }
             }
@@ -67,6 +67,7 @@ class DependencyGraphBuilder {
         private final DependencyNode[] parameters;
         private final DependencyNode result;
         private final DependencyStack stack;
+        private final ConcurrentMap<MethodReference, MethodReference> knownMethods = new ConcurrentHashMap<>();
 
         public VirtualCallPropagationListener(DependencyNode node, MethodDescriptor methodDesc,
                 DependencyChecker checker, DependencyNode[] parameters, DependencyNode result,
@@ -89,262 +90,256 @@ class DependencyGraphBuilder {
                 className = "java.lang.Object";
             }
             MethodReference methodRef = new MethodReference(className, methodDesc);
-            MethodHolder method = findMethod(methodRef, checker.getClassSource());
+            MethodDependency methodDep = checker.linkMethod(methodRef, stack);
-            if (method == null) {
+            if (!methodDep.isMissing() && knownMethods.putIfAbsent(methodRef, methodRef) == null) {
-                return;
+                DependencyNode[] targetParams = methodDep.getVariables();
-            }
+                for (int i = 0; i < parameters.length; ++i) {
-            MethodGraph targetGraph = checker.attachMethodGraph(methodRef, stack);
+                    parameters[i].connect(targetParams[i]);
-            DependencyNode[] targetParams = targetGraph.getVariables();
+                }
-            for (int i = 0; i < parameters.length; ++i) {
+                if (methodDep.getResult() != null) {
-                parameters[i].connect(targetParams[i]);
+                    methodDep.getResult().connect(result);
-            }
-            if (targetGraph.getResult() != null) {
-                targetGraph.getResult().connect(result);
-            }
-        }
-    }
-
-    private static MethodHolder findMethod(MethodReference methodRef, ClassHolderSource classSource) {
-        String className = methodRef.getClassName();
-        while (className != null) {
-            ClassHolder cls = classSource.get(className);
-            if (cls == null) {
-                break;
-            }
-            MethodHolder method = cls.getMethod(methodRef.getDescriptor());
-            if (method != null) {
-                return method;
-            }
-            className = cls.getParent();
-        }
-        return null;
-    }
-
-    private InstructionVisitor visitor = new InstructionVisitor() {
-        @Override
-        public void visit(IsInstanceInstruction insn) {
-        }
-
-        @Override
-        public void visit(InvokeInstruction insn) {
-            if (insn.getInstance() == null) {
-                invokeSpecial(insn);
-            } else {
-                switch (insn.getType()) {
-                    case SPECIAL:
-                        invokeSpecial(insn);
-                        break;
-                    case VIRTUAL:
-                        invokeVirtual(insn);
-                        break;
                 }
             }
         }
+    }
 
-        private void invokeSpecial(InvokeInstruction insn) {
+    private InstructionReader reader = new InstructionReader() {
-            MethodGraph targetGraph = dependencyChecker.attachMethodGraph(insn.getMethod(), callerStack);
+        @Override
-            DependencyNode[] targetParams = targetGraph.getVariables();
+        public void nop() {
-            List<Variable> arguments = insn.getArguments();
-            for (int i = 0; i < arguments.size(); ++i) {
-                nodes[arguments.get(i).getIndex()].connect(targetParams[i + 1]);
-            }
-            if (insn.getInstance() != null) {
-                nodes[insn.getInstance().getIndex()].connect(targetParams[0]);
-            }
-            if (targetGraph.getResult() != null && insn.getReceiver() != null) {
-                targetGraph.getResult().connect(nodes[insn.getReceiver().getIndex()]);
-            }
-        }
-
-        private void invokeVirtual(InvokeInstruction insn) {
-            List<Variable> arguments = insn.getArguments();
-            DependencyNode[] actualArgs = new DependencyNode[arguments.size() + 1];
-            for (int i = 0; i < arguments.size(); ++i) {
-                actualArgs[i + 1] = nodes[arguments.get(i).getIndex()];
-            }
-            actualArgs[0] = nodes[insn.getInstance().getIndex()];
-            DependencyConsumer listener = new VirtualCallPropagationListener(nodes[insn.getInstance().getIndex()],
-                    insn.getMethod().getDescriptor(), dependencyChecker, actualArgs,
-                    insn.getReceiver() != null ? nodes[insn.getReceiver().getIndex()] : null, callerStack);
-            dependencyChecker.addAbstractMethod(insn.getMethod(), callerStack);
-            nodes[insn.getInstance().getIndex()].addConsumer(listener);
         }
 
         @Override
-        public void visit(PutElementInstruction insn) {
+        public void classConstant(VariableReader receiver, ValueType cst) {
-            DependencyNode valueNode = nodes[insn.getValue().getIndex()];
+            nodes[receiver.getIndex()].propagate("java.lang.Class");
-            DependencyNode arrayNode = nodes[insn.getArray().getIndex()];
+            while (cst instanceof ValueType.Array) {
-            valueNode.connect(arrayNode.getArrayItem());
+                cst = ((ValueType.Array)cst).getItemType();
+            }
+            if (cst instanceof ValueType.Object) {
+                dependencyChecker.achieveClass(((ValueType.Object)cst).getClassName(), callerStack);
+            }
         }
 
         @Override
-        public void visit(GetElementInstruction insn) {
+        public void nullConstant(VariableReader receiver) {
-            DependencyNode arrayNode = nodes[insn.getArray().getIndex()];
-            DependencyNode receiverNode = nodes[insn.getReceiver().getIndex()];
-            arrayNode.getArrayItem().connect(receiverNode);
         }
 
         @Override
-        public void visit(UnwrapArrayInstruction insn) {
+        public void integerConstant(VariableReader receiver, int cst) {
-            DependencyNode arrayNode = nodes[insn.getArray().getIndex()];
-            DependencyNode receiverNode = nodes[insn.getReceiver().getIndex()];
-            arrayNode.connect(receiverNode);
         }
 
         @Override
-        public void visit(CloneArrayInstruction insn) {
+        public void longConstant(VariableReader receiver, long cst) {
-            DependencyNode arrayNode = nodes[insn.getArray().getIndex()];
+        }
-            final DependencyNode receiverNode = nodes[insn.getReceiver().getIndex()];
+
+        @Override
+        public void floatConstant(VariableReader receiver, float cst) {
+        }
+
+        @Override
+        public void doubleConstant(VariableReader receiver, double cst) {
+        }
+
+        @Override
+        public void stringConstant(VariableReader receiver, String cst) {
+            nodes[receiver.getIndex()].propagate("java.lang.String");
+            dependencyChecker.linkMethod(new MethodReference("java.lang.String", new MethodDescriptor(
+                    "<init>", ValueType.arrayOf(ValueType.CHARACTER), ValueType.VOID)), callerStack);
+        }
+
+        @Override
+        public void binary(BinaryOperation op, VariableReader receiver, VariableReader first, VariableReader second,
+                NumericOperandType type) {
+        }
+
+        @Override
+        public void negate(VariableReader receiver, VariableReader operand, NumericOperandType type) {
+        }
+
+        @Override
+        public void assign(VariableReader receiver, VariableReader assignee) {
+            DependencyNode valueNode = nodes[assignee.getIndex()];
+            DependencyNode receiverNode = nodes[receiver.getIndex()];
+            valueNode.connect(receiverNode);
+        }
+
+        @Override
+        public void cast(VariableReader receiver, VariableReader value, ValueType targetType) {
+            DependencyNode valueNode = nodes[value.getIndex()];
+            DependencyNode receiverNode = nodes[receiver.getIndex()];
+            valueNode.connect(receiverNode);
+        }
+
+        @Override
+        public void cast(VariableReader receiver, VariableReader value, NumericOperandType sourceType,
+                NumericOperandType targetType) {
+        }
+
+        @Override
+        public void cast(VariableReader receiver, VariableReader value, IntegerSubtype type,
+                CastIntegerDirection targetType) {
+        }
+
+        @Override
+        public void jumpIf(BranchingCondition cond, VariableReader operand, BasicBlockReader consequent,
+                BasicBlockReader alternative) {
+        }
+
+        @Override
+        public void jumpIf(BinaryBranchingCondition cond, VariableReader first, VariableReader second,
+                BasicBlockReader consequent, BasicBlockReader alternative) {
+        }
+
+        @Override
+        public void jump(BasicBlockReader target) {
+        }
+
+        @Override
+        public void choose(VariableReader condition, List<? extends SwitchTableEntryReader> table,
+                BasicBlockReader defaultTarget) {
+        }
+
+        @Override
+        public void exit(VariableReader valueToReturn) {
+            if (valueToReturn != null) {
+                nodes[valueToReturn.getIndex()].connect(resultNode);
+            }
+        }
+
+        @Override
+        public void raise(VariableReader exception) {
+        }
+
+        @Override
+        public void createArray(VariableReader receiver, ValueType itemType, VariableReader size) {
+            nodes[receiver.getIndex()].propagate("[" + itemType);
+        }
+
+        @Override
+        public void createArray(VariableReader receiver, ValueType itemType,
+                List<? extends VariableReader> dimensions) {
+            StringBuilder sb = new StringBuilder();
+            for (int i = 0; i < dimensions.size(); ++i) {
+                sb.append('[');
+            }
+            sb.append(itemType);
+            nodes[receiver.getIndex()].propagate(sb.toString());
+        }
+
+        @Override
+        public void create(VariableReader receiver, String type) {
+            nodes[receiver.getIndex()].propagate(type);
+        }
+
+        @Override
+        public void getField(VariableReader receiver, VariableReader instance, FieldReference field,
+                ValueType fieldType) {
+            DependencyNode fieldNode = dependencyChecker.linkField(field, callerStack);
+            DependencyNode receiverNode = nodes[receiver.getIndex()];
+            fieldNode.connect(receiverNode);
+        }
+
+        @Override
+        public void putField(VariableReader instance, FieldReference field, VariableReader value) {
+            DependencyNode fieldNode = dependencyChecker.linkField(field, callerStack);
+            DependencyNode valueNode = nodes[value.getIndex()];
+            valueNode.connect(fieldNode);
+        }
+
+        @Override
+        public void arrayLength(VariableReader receiver, VariableReader array) {
+        }
+
+        @Override
+        public void cloneArray(VariableReader receiver, VariableReader array) {
+            DependencyNode arrayNode = nodes[array.getIndex()];
+            final DependencyNode receiverNode = nodes[receiver.getIndex()];
             arrayNode.addConsumer(new DependencyConsumer() {
                 @Override public void consume(String type) {
                     receiverNode.propagate(type);
-
                 }
             });
             arrayNode.getArrayItem().connect(receiverNode.getArrayItem());
         }
 
         @Override
-        public void visit(ArrayLengthInstruction insn) {
+        public void unwrapArray(VariableReader receiver, VariableReader array, ArrayElementType elementType) {
+            DependencyNode arrayNode = nodes[array.getIndex()];
+            DependencyNode receiverNode = nodes[receiver.getIndex()];
+            arrayNode.connect(receiverNode);
         }
 
         @Override
-        public void visit(PutFieldInstruction insn) {
+        public void getElement(VariableReader receiver, VariableReader array, VariableReader index) {
-            DependencyNode fieldNode = dependencyChecker.attachFieldNode(insn.getField(), callerStack);
+            DependencyNode arrayNode = nodes[array.getIndex()];
-            DependencyNode valueNode = nodes[insn.getValue().getIndex()];
+            DependencyNode receiverNode = nodes[receiver.getIndex()];
-            valueNode.connect(fieldNode);
+            arrayNode.getArrayItem().connect(receiverNode);
         }
 
         @Override
-        public void visit(GetFieldInstruction insn) {
+        public void putElement(VariableReader array, VariableReader index, VariableReader value) {
-            DependencyNode fieldNode = dependencyChecker.attachFieldNode(insn.getField(), callerStack);
+            DependencyNode valueNode = nodes[value.getIndex()];
-            DependencyNode receiverNode = nodes[insn.getReceiver().getIndex()];
+            DependencyNode arrayNode = nodes[array.getIndex()];
-            fieldNode.connect(receiverNode);
+            valueNode.connect(arrayNode.getArrayItem());
         }
 
         @Override
-        public void visit(ConstructMultiArrayInstruction insn) {
+        public void invoke(VariableReader receiver, VariableReader instance, MethodReference method,
-            StringBuilder sb = new StringBuilder();
+                List<? extends VariableReader> arguments, InvocationType type) {
-            for (int i = 0; i < insn.getDimensions().size(); ++i) {
+            if (instance == null) {
-                sb.append('[');
+                invokeSpecial(receiver, instance, method, arguments);
-            }
+            } else {
-            sb.append(insn.getItemType());
+                switch (type) {
-            nodes[insn.getReceiver().getIndex()].propagate(sb.toString());
+                    case SPECIAL:
-        }
+                        invokeSpecial(receiver, instance, method, arguments);
-
+                        break;
-        @Override
+                    case VIRTUAL:
-        public void visit(ConstructInstruction insn) {
+                        invokeVirtual(receiver, instance, method, arguments);
-            nodes[insn.getReceiver().getIndex()].propagate(insn.getType());
+                        break;
-        }
+                }
-
-        @Override
-        public void visit(ConstructArrayInstruction insn) {
-            nodes[insn.getReceiver().getIndex()].propagate("[" + insn.getItemType());
-        }
-
-        @Override
-        public void visit(RaiseInstruction insn) {
-        }
-
-        @Override
-        public void visit(ExitInstruction insn) {
-            if (insn.getValueToReturn() != null) {
-                nodes[insn.getValueToReturn().getIndex()].connect(resultNode);
             }
         }
 
-        @Override
+        private void invokeSpecial(VariableReader receiver, VariableReader instance, MethodReference method,
-        public void visit(SwitchInstruction insn) {
+                List<? extends VariableReader> arguments) {
-        }
+            MethodDependency methodDep = dependencyChecker.linkMethod(method, callerStack);
-
+            if (methodDep.isMissing()) {
-        @Override
+                return;
-        public void visit(JumpInstruction insn) {
-        }
-
-        @Override
-        public void visit(BinaryBranchingInstruction insn) {
-        }
-
-        @Override
-        public void visit(BranchingInstruction insn) {
-        }
-
-        @Override
-        public void visit(CastNumberInstruction insn) {
-        }
-
-        @Override
-        public void visit(CastInstruction insn) {
-            DependencyNode valueNode = nodes[insn.getValue().getIndex()];
-            DependencyNode receiverNode = nodes[insn.getReceiver().getIndex()];
-            valueNode.connect(receiverNode);
-        }
-
-        @Override
-        public void visit(CastIntegerInstruction insn) {
-        }
-
-        @Override
-        public void visit(AssignInstruction insn) {
-            DependencyNode valueNode = nodes[insn.getAssignee().getIndex()];
-            DependencyNode receiverNode = nodes[insn.getReceiver().getIndex()];
-            valueNode.connect(receiverNode);
-        }
-
-        @Override
-        public void visit(NegateInstruction insn) {
-        }
-
-        @Override
-        public void visit(BinaryInstruction insn) {
-        }
-
-        @Override
-        public void visit(StringConstantInstruction insn) {
-            nodes[insn.getReceiver().getIndex()].propagate("java.lang.String");
-            dependencyChecker.attachMethodGraph(new MethodReference("java.lang.String", new MethodDescriptor(
-                    "<init>", ValueType.arrayOf(ValueType.CHARACTER), ValueType.VOID)), callerStack);
-        }
-
-        @Override
-        public void visit(DoubleConstantInstruction insn) {
-        }
-
-        @Override
-        public void visit(FloatConstantInstruction insn) {
-        }
-
-        @Override
-        public void visit(LongConstantInstruction insn) {
-        }
-
-        @Override
-        public void visit(IntegerConstantInstruction insn) {
-        }
-
-        @Override
-        public void visit(NullConstantInstruction insn) {
-        }
-
-        @Override
-        public void visit(ClassConstantInstruction insn) {
-            nodes[insn.getReceiver().getIndex()].propagate("java.lang.Class");
-            ValueType type = insn.getConstant();
-            while (type instanceof ValueType.Array) {
-                type = ((ValueType.Array)type).getItemType();
             }
-            if (type instanceof ValueType.Object) {
+            DependencyNode[] targetParams = methodDep.getVariables();
-                dependencyChecker.achieveClass(((ValueType.Object)type).getClassName(), callerStack);
+            for (int i = 0; i < arguments.size(); ++i) {
+                nodes[arguments.get(i).getIndex()].connect(targetParams[i + 1]);
+            }
+            if (instance != null) {
+                nodes[instance.getIndex()].connect(targetParams[0]);
+            }
+            if (methodDep.getResult() != null && receiver != null) {
+                methodDep.getResult().connect(nodes[receiver.getIndex()]);
             }
         }
 
-        @Override
+        private void invokeVirtual(VariableReader receiver, VariableReader instance, MethodReference method,
-        public void visit(EmptyInstruction insn) {
+                List<? extends VariableReader> arguments) {
+            if (dependencyChecker.linkMethod(method, callerStack).isMissing()) {
+                return;
+            }
+            DependencyNode[] actualArgs = new DependencyNode[arguments.size() + 1];
+            for (int i = 0; i < arguments.size(); ++i) {
+                actualArgs[i + 1] = nodes[arguments.get(i).getIndex()];
+            }
+            actualArgs[0] = nodes[instance.getIndex()];
+            DependencyConsumer listener = new VirtualCallPropagationListener(nodes[instance.getIndex()],
+                    method.getDescriptor(), dependencyChecker, actualArgs,
+                    receiver != null ? nodes[receiver.getIndex()] : null, callerStack);
+            nodes[instance.getIndex()].addConsumer(listener);
         }
 
         @Override
-        public void visit(InitClassInstruction insn) {
+        public void isInstance(VariableReader receiver, VariableReader value, ValueType type) {
-            dependencyChecker.initClass(insn.getClassName(), callerStack);
+        }
+
+        @Override
+        public void initClass(String className) {
+            dependencyChecker.initClass(className, callerStack);
         }
     };
 }

teavm-core/src/main/java/org/teavm/dependency/DependencyListener.java

@@ -26,7 +26,7 @@ public interface DependencyListener {
 
     void classAchieved(DependencyChecker dependencyChecker, String className);
 
-    void methodAchieved(DependencyChecker dependencyChecker, MethodGraph method);
+    void methodAchieved(DependencyChecker dependencyChecker, MethodDependency method);
 
     void fieldAchieved(DependencyChecker dependencyChecker, FieldReference field, DependencyNode node);
 }

teavm-core/src/main/java/org/teavm/dependency/DependencyPlugin.java

@@ -20,5 +20,5 @@ package org.teavm.dependency;
  * @author Alexey Andreev
  */
 public interface DependencyPlugin {
-    void methodAchieved(DependencyChecker checker, MethodGraph graph);
+    void methodAchieved(DependencyChecker checker, MethodDependency graph);
 }

teavm-core/src/main/java/org/teavm/dependency/MethodDependency.java

@@ -16,25 +16,28 @@
 package org.teavm.dependency;
 
 import java.util.Arrays;
+import org.teavm.model.MethodReader;
 import org.teavm.model.MethodReference;
 
 /**
  *
  * @author Alexey Andreev
  */
-public class MethodGraph implements DependencyMethodInformation {
+public class MethodDependency implements DependencyMethodInformation {
     private DependencyNode[] variableNodes;
     private int parameterCount;
     private DependencyNode resultNode;
     private DependencyStack stack;
+    private MethodReader method;
     private MethodReference reference;
 
-    MethodGraph(DependencyNode[] variableNodes, int parameterCount, DependencyNode resultNode,
+    MethodDependency(DependencyNode[] variableNodes, int parameterCount, DependencyNode resultNode,
-            DependencyStack stack, MethodReference reference) {
+            DependencyStack stack, MethodReader method, MethodReference reference) {
         this.variableNodes = Arrays.copyOf(variableNodes, variableNodes.length);
         this.parameterCount = parameterCount;
         this.resultNode = resultNode;
         this.stack = stack;
+        this.method = method;
         this.reference = reference;
     }
 
@@ -70,4 +73,12 @@ public class MethodGraph implements DependencyMethodInformation {
     public MethodReference getReference() {
         return reference;
     }
+
+    public MethodReader getMethod() {
+        return method;
+    }
+
+    public boolean isMissing() {
+        return method == null;
+    }
 }

teavm-core/src/main/java/org/teavm/javascript/JavascriptBuilder.java

@@ -91,7 +91,7 @@ public class JavascriptBuilder implements JavascriptBuilderHost {
                     "for method " + ref);
         }
         JavascriptEntryPoint entryPoint = new JavascriptEntryPoint(name, ref,
-                dependencyChecker.attachMethodGraph(ref, DependencyStack.ROOT));
+                dependencyChecker.linkMethod(ref, DependencyStack.ROOT));
         entryPoints.put(name, entryPoint);
         return entryPoint;
     }
@@ -119,13 +119,13 @@ public class JavascriptBuilder implements JavascriptBuilderHost {
         SourceWriterBuilder builder = new SourceWriterBuilder(naming);
         builder.setMinified(minifying);
         SourceWriter sourceWriter = builder.build(writer);
-        dependencyChecker.attachMethodGraph(new MethodReference("java.lang.Class", new MethodDescriptor("createNew",
+        dependencyChecker.linkMethod(new MethodReference("java.lang.Class", new MethodDescriptor("createNew",
                 ValueType.object("java.lang.Class"))), DependencyStack.ROOT);
-        dependencyChecker.attachMethodGraph(new MethodReference("java.lang.String", new MethodDescriptor("<init>",
+        dependencyChecker.linkMethod(new MethodReference("java.lang.String", new MethodDescriptor("<init>",
                 ValueType.arrayOf(ValueType.CHARACTER), ValueType.VOID)), DependencyStack.ROOT);
         executor.complete();
         dependencyChecker.checkForMissingItems();
-        ListableClassHolderSource classSet = dependencyChecker.cutUnachievableClasses();
+        ListableClassHolderSource classSet = dependencyChecker.cutUnachievableClasses(classSource);
         Decompiler decompiler = new Decompiler(classSet, classLoader, executor);
         devirtualize(classSet, dependencyChecker);
         executor.complete();

teavm-core/src/main/java/org/teavm/javascript/JavascriptEntryPoint.java

@@ -15,7 +15,7 @@
  */
 package org.teavm.javascript;
 
-import org.teavm.dependency.MethodGraph;
+import org.teavm.dependency.MethodDependency;
 import org.teavm.model.MethodReference;
 
 /**
@@ -25,9 +25,9 @@ import org.teavm.model.MethodReference;
 public class JavascriptEntryPoint {
     private String publicName;
     MethodReference reference;
-    private MethodGraph graph;
+    private MethodDependency graph;
 
-    JavascriptEntryPoint(String publicName, MethodReference reference, MethodGraph graph) {
+    JavascriptEntryPoint(String publicName, MethodReference reference, MethodDependency graph) {
         this.publicName = publicName;
         this.reference = reference;
         this.graph = graph;

teavm-core/src/main/java/org/teavm/model/FieldHolder.java

@@ -59,4 +59,9 @@ public class FieldHolder extends MemberHolder implements FieldReader {
     public String getOwnerName() {
         return owner != null ? owner.getName() : null;
     }
+
+    @Override
+    public FieldReference getReference() {
+        return new FieldReference(getOwnerName(), getName());
+    }
 }

teavm-core/src/main/java/org/teavm/model/FieldReader.java

@@ -23,4 +23,6 @@ public interface FieldReader extends MemberReader {
     ValueType getType();
 
     Object getInitialValue();
+
+    FieldReference getReference();
 }

teavm-core/src/main/java/org/teavm/model/util/InstructionStringifier.java

@@ -16,14 +16,14 @@
 package org.teavm.model.util;
 
 import java.util.List;
-import org.teavm.model.Variable;
+import org.teavm.model.*;
 import org.teavm.model.instructions.*;
 
 /**
  *
  * @author Alexey Andreev
  */
-public class InstructionStringifier implements InstructionVisitor {
+public class InstructionStringifier implements InstructionReader {
     private StringBuilder sb;
 
     public InstructionStringifier(StringBuilder sb) {
@@ -31,56 +31,50 @@ public class InstructionStringifier implements InstructionVisitor {
     }
 
     @Override
-    public void visit(EmptyInstruction insn) {
+    public void nop() {
         sb.append("nop");
     }
 
     @Override
-    public void visit(ClassConstantInstruction insn) {
+    public void classConstant(VariableReader receiver, ValueType cst) {
-        sb.append("@").append(insn.getReceiver().getIndex()).append(" := classOf ")
+        sb.append("@").append(receiver.getIndex()).append(" := classOf ").append(cst);
-                .append(insn.getConstant());
     }
 
     @Override
-    public void visit(NullConstantInstruction insn) {
+    public void nullConstant(VariableReader receiver) {
-        sb.append("@").append(insn.getReceiver().getIndex()).append(" := null");
+        sb.append("@").append(receiver.getIndex()).append(" := null");
     }
 
     @Override
-    public void visit(IntegerConstantInstruction insn) {
+    public void integerConstant(VariableReader receiver, int cst) {
-        sb.append("@").append(insn.getReceiver().getIndex()).append(" := ")
+        sb.append("@").append(receiver.getIndex()).append(" := ").append(cst);
-                .append(insn.getConstant());
     }
 
     @Override
-    public void visit(LongConstantInstruction insn) {
+    public void longConstant(VariableReader receiver, long cst) {
-        sb.append("@").append(insn.getReceiver().getIndex()).append(" := ")
+        sb.append("@").append(receiver.getIndex()).append(" := ").append(cst);
-                .append(insn.getConstant());
     }
 
     @Override
-    public void visit(FloatConstantInstruction insn) {
+    public void floatConstant(VariableReader receiver, float cst) {
-        sb.append("@").append(insn.getReceiver().getIndex()).append(" := ")
+        sb.append("@").append(receiver.getIndex()).append(" := ").append(cst);
-                .append(insn.getConstant());
     }
 
     @Override
-    public void visit(DoubleConstantInstruction insn) {
+    public void doubleConstant(VariableReader receiver, double cst) {
-        sb.append("@").append(insn.getReceiver().getIndex()).append(" := ")
+        sb.append("@").append(receiver.getIndex()).append(" := ").append(cst);
-                .append(insn.getConstant());
     }
 
     @Override
-    public void visit(StringConstantInstruction insn) {
+    public void stringConstant(VariableReader receiver, String cst) {
-        sb.append("@").append(insn.getReceiver().getIndex()).append(" := '")
+        sb.append("@").append(receiver.getIndex()).append(" := '").append(cst).append("'");
-                .append(insn.getConstant()).append("'");
     }
 
     @Override
-    public void visit(BinaryInstruction insn) {
+    public void binary(BinaryOperation op, VariableReader receiver, VariableReader first, VariableReader second,
-        sb.append("@").append(insn.getReceiver().getIndex()).append(" := @")
+            NumericOperandType type) {
-                .append(insn.getFirstOperand().getIndex()).append(" ");
+        sb.append("@").append(receiver.getIndex()).append(" := @").append(first.getIndex()).append(" ");
-        switch (insn.getOperation()) {
+        switch (op) {
             case ADD:
                 sb.append("+");
                 break;
@@ -118,25 +112,51 @@ public class InstructionStringifier implements InstructionVisitor {
                 sb.append("^");
                 break;
         }
-        sb.append(" @").append(insn.getSecondOperand().getIndex());
+        sb.append(" @").append(second.getIndex());
     }
 
     @Override
-    public void visit(NegateInstruction insn) {
+    public void negate(VariableReader receiver, VariableReader operand, NumericOperandType type) {
-        sb.append("@").append(insn.getReceiver().getIndex()).append(" := -")
+        sb.append("@").append(receiver.getIndex()).append(" := -").append(" @").append(operand.getIndex());
-                .append(" @").append(insn.getOperand().getIndex());
     }
 
     @Override
-    public void visit(AssignInstruction insn) {
+    public void assign(VariableReader receiver, VariableReader assignee) {
-        sb.append("@").append(insn.getReceiver().getIndex()).append(" := @")
+        sb.append("@").append(receiver.getIndex()).append(" := @").append(assignee.getIndex());
-                .append(insn.getAssignee().getIndex());
     }
 
     @Override
-    public void visit(BranchingInstruction insn) {
+    public void cast(VariableReader receiver, VariableReader value, ValueType targetType) {
-        sb.append("if @").append(insn.getOperand().getIndex()).append(" ");
+        sb.append("@").append(receiver.getIndex()).append(" := cast @").append(value.getIndex())
-        switch (insn.getCondition()) {
+                .append(" to ").append(targetType);
+    }
+
+    @Override
+    public void cast(VariableReader receiver, VariableReader value, NumericOperandType sourceType,
+            NumericOperandType targetType) {
+        sb.append("@").append(receiver.getIndex()).append(" := cast @").append(value.getIndex())
+                .append(" from ").append(sourceType).append(" to ").append(targetType);
+    }
+
+    @Override
+    public void cast(VariableReader receiver, VariableReader value, IntegerSubtype type,
+            CastIntegerDirection direction) {
+        sb.append("@").append(receiver.getIndex()).append(" := cast @").append(value.getIndex());
+        switch (direction) {
+            case FROM_INTEGER:
+                sb.append(" from INT to ").append(type);
+                break;
+            case TO_INTEGER:
+                sb.append(" from ").append(type).append(" to INT");
+                break;
+        }
+    }
+
+    @Override
+    public void jumpIf(BranchingCondition cond, VariableReader operand, BasicBlockReader consequent,
+            BasicBlockReader alternative) {
+        sb.append("if @").append(operand.getIndex()).append(" ");
+        switch (cond) {
             case EQUAL:
                 sb.append("== 0");
                 break;
@@ -162,14 +182,14 @@ public class InstructionStringifier implements InstructionVisitor {
                 sb.append("== null");
                 break;
         }
-        sb.append(" then goto $").append(insn.getConsequent().getIndex()).append(" else goto $")
+        sb.append(" then goto $").append(consequent.getIndex()).append(" else goto $").append(alternative.getIndex());
-                .append(insn.getAlternative().getIndex());
     }
 
     @Override
-    public void visit(BinaryBranchingInstruction insn) {
+    public void jumpIf(BinaryBranchingCondition cond, VariableReader first, VariableReader second,
-        sb.append("if @").append(insn.getFirstOperand().getIndex()).append(" ");
+            BasicBlockReader consequent, BasicBlockReader alternative) {
-        switch (insn.getCondition()) {
+        sb.append("if @").append(first.getIndex()).append(" ");
+        switch (cond) {
             case EQUAL:
             case REFERENCE_EQUAL:
                 sb.append("==");
@@ -179,119 +199,125 @@ public class InstructionStringifier implements InstructionVisitor {
                 sb.append("!=");
                 break;
         }
-        sb.append("@").append(insn.getSecondOperand().getIndex())
+        sb.append("@").append(second.getIndex()).append(" then goto $").append(consequent.getIndex())
-                .append(" then goto $").append(insn.getConsequent().getIndex())
+                .append(" else goto $").append(alternative.getIndex());
-                .append(" else goto $").append(insn.getAlternative().getIndex());
     }
 
     @Override
-    public void visit(JumpInstruction insn) {
+    public void jump(BasicBlockReader target) {
-        sb.append("goto $").append(insn.getTarget().getIndex());
+        sb.append("goto $").append(target.getIndex());
     }
 
     @Override
-    public void visit(SwitchInstruction insn) {
+    public void choose(VariableReader condition, List<? extends SwitchTableEntryReader> table,
-        sb.append("switch @").append(insn.getCondition().getIndex()).append(" ");
+            BasicBlockReader defaultTarget) {
-        List<SwitchTableEntry> entries = insn.getEntries();
+        sb.append("switch @").append(condition.getIndex()).append(" ");
-        for (int i = 0; i < entries.size(); ++i) {
+        for (int i = 0; i < table.size(); ++i) {
             if (i > 0) {
                 sb.append("; ");
             }
-            SwitchTableEntry entry = entries.get(i);
+            SwitchTableEntryReader entry = table.get(i);
-            sb.append("case ").append(entry.getCondition()).append(": goto $")
+            sb.append("case ").append(entry.getCondition()).append(": goto $").append(entry.getTarget());
-                    .append(entry.getTarget());
         }
-        sb.append(", default: goto $").append(insn.getDefaultTarget());
+        sb.append(", default: goto $").append(defaultTarget.getIndex());
     }
 
     @Override
-    public void visit(ExitInstruction insn) {
+    public void exit(VariableReader valueToReturn) {
         sb.append("return");
-        if (insn.getValueToReturn() != null) {
+        if (valueToReturn != null) {
-            sb.append(" @").append(insn.getValueToReturn().getIndex());
+            sb.append(" @").append(valueToReturn.getIndex());
         }
     }
 
     @Override
-    public void visit(RaiseInstruction insn) {
+    public void raise(VariableReader exception) {
-        sb.append("throw @").append(insn.getException().getIndex());
+        sb.append("throw @").append(exception.getIndex());
     }
 
     @Override
-    public void visit(ConstructArrayInstruction insn) {
+    public void createArray(VariableReader receiver, ValueType itemType, VariableReader size) {
-        sb.append("@").append(insn.getReceiver().getIndex()).append(" = new ")
+        sb.append("@").append(receiver.getIndex()).append(" = new ").append(itemType).append("[@")
-                .append(insn.getItemType()).append("[@").append(insn.getSize().getIndex())
+                .append(size.getIndex()).append(']');
-                .append(']');
     }
 
     @Override
-    public void visit(ConstructInstruction insn) {
+    public void createArray(VariableReader receiver, ValueType itemType, List<? extends VariableReader> dimensions) {
-        sb.append("@").append(insn.getReceiver().getIndex()).append(" = new ")
+        sb.append("@").append(receiver.getIndex()).append(" = new ").append(itemType).append("[");
-                .append(insn.getType()).append("()");
-    }
-
-    @Override
-    public void visit(ConstructMultiArrayInstruction insn) {
-        sb.append("@").append(insn.getReceiver().getIndex()).append(" = new ")
-                .append(insn.getItemType()).append("[");
-        List<Variable> dimensions = insn.getDimensions();
         for (int i = 0; i < dimensions.size(); ++i) {
             if (i > 0) {
                 sb.append(", ");
             }
-            Variable dimension = dimensions.get(i);
+            sb.append("@").append(dimensions.get(i).getIndex());
-            sb.append("@").append(dimension.getIndex());
         }
         sb.append("]");
     }
 
     @Override
-    public void visit(GetFieldInstruction insn) {
+    public void create(VariableReader receiver, String type) {
-        sb.append("@").append(insn.getReceiver().getIndex()).append(" := ");
+        sb.append("@").append(receiver.getIndex()).append(" = new ").append(type).append("()");
-        if (insn.getInstance() != null) {
+    }
-            sb.append("@").append(insn.getInstance().getIndex());
+
+    @Override
+    public void getField(VariableReader receiver, VariableReader instance, FieldReference field, ValueType fieldType) {
+        sb.append("@").append(receiver.getIndex()).append(" := ");
+        if (instance != null) {
+            sb.append("@").append(instance.getIndex());
         } else {
-            sb.append(insn.getField().getClassName());
+            sb.append(field.getClassName());
         }
-        sb.append(".").append(insn.getField().getFieldName());
+        sb.append(".").append(field.getFieldName());
     }
 
     @Override
-    public void visit(PutFieldInstruction insn) {
+    public void putField(VariableReader instance, FieldReference field, VariableReader value) {
-        if (insn.getInstance() != null) {
+        if (instance != null) {
-            sb.append("@").append(insn.getInstance().getIndex());
+            sb.append("@").append(instance.getIndex());
         } else {
-            sb.append(insn.getField().getClassName());
+            sb.append(field.getClassName());
         }
-        sb.append(".").append(insn.getField().getFieldName()).append(" := @").append(insn.getValue().getIndex());
+        sb.append(".").append(field.getFieldName()).append(" := @").append(value.getIndex());
     }
 
     @Override
-    public void visit(GetElementInstruction insn) {
+    public void arrayLength(VariableReader receiver, VariableReader array) {
-        sb.append("@").append(insn.getReceiver().getIndex()).append(" := @")
+        sb.append("@").append(receiver.getIndex()).append(" := @").append(array.getIndex()).append(".length");
-                .append(insn.getArray().getIndex()).append("[@")
-                .append(insn.getIndex().getIndex()).append("]");
     }
 
     @Override
-    public void visit(PutElementInstruction insn) {
+    public void cloneArray(VariableReader receiver, VariableReader array) {
-        sb.append("@").append(insn.getArray().getIndex()).append("[@")
+        sb.append("@").append(receiver.getIndex()).append("@").append(array.getIndex()).append(".clone()");
-                .append(insn.getIndex().getIndex()).append("] := @")
-                .append(insn.getValue().getIndex());
     }
 
     @Override
-    public void visit(InvokeInstruction insn) {
+    public void unwrapArray(VariableReader receiver, VariableReader array, ArrayElementType elementType) {
-        if (insn.getReceiver() != null) {
+        sb.append("@").append(receiver.getIndex()).append(" := @").append(array.getIndex()).append(".data");
-            sb.append("@").append(insn.getReceiver().getIndex()).append(" := ");
+    }
+
+    @Override
+    public void getElement(VariableReader receiver, VariableReader array, VariableReader index) {
+        sb.append("@").append(receiver.getIndex()).append(" := @").append(array.getIndex()).append("[@")
+                .append(index.getIndex()).append("]");
+    }
+
+    @Override
+    public void putElement(VariableReader array, VariableReader index, VariableReader value) {
+        sb.append("@").append(array.getIndex()).append("[@").append(index.getIndex()).append("] := @")
+                .append(value.getIndex());
+    }
+
+    @Override
+    public void invoke(VariableReader receiver, VariableReader instance, MethodReference method,
+            List<? extends VariableReader> arguments, InvocationType type) {
+        if (receiver != null) {
+            sb.append("@").append(receiver.getIndex()).append(" := ");
         }
-        if (insn.getInstance() != null) {
+        if (instance != null) {
-            sb.append("@").append(insn.getInstance().getIndex());
+            sb.append("@").append(instance.getIndex());
         } else {
-            sb.append(insn.getMethod().getClassName());
+            sb.append(method.getClassName());
         }
-        sb.append(".").append(insn.getMethod().getName()).append("(");
+        sb.append(".").append(method.getName()).append("(");
-        List<Variable> arguments = insn.getArguments();
         for (int i = 0; i < arguments.size(); ++i) {
             if (i > 0) {
                 sb.append(", ");
@@ -302,53 +328,13 @@ public class InstructionStringifier implements InstructionVisitor {
     }
 
     @Override
-    public void visit(IsInstanceInstruction insn) {
+    public void isInstance(VariableReader receiver, VariableReader value, ValueType type) {
-        sb.append("@").append(insn.getReceiver().getIndex()).append(" := @")
+        sb.append("@").append(receiver.getIndex()).append(" := @").append(value.getIndex())
-                .append(insn.getValue().getIndex()).append(" instanceof ").append(insn.getType());
+                .append(" instanceof ").append(type);
     }
 
     @Override
-    public void visit(CastInstruction insn) {
+    public void initClass(String className) {
-        sb.append("@").append(insn.getReceiver().getIndex()).append(" := cast @")
+        sb.append("initclass ").append(className);
-                .append(insn.getValue().getIndex()).append(" to ")
-                .append(insn.getTargetType());
-    }
-
-    @Override
-    public void visit(CastNumberInstruction insn) {
-        sb.append("@").append(insn.getReceiver().getIndex()).append(" := cast @")
-                .append(insn.getValue().getIndex())
-                .append(" from ").append(insn.getSourceType())
-                .append(" to ").append(insn.getTargetType());
-    }
-
-    @Override
-    public void visit(CastIntegerInstruction insn) {
-        sb.append("@").append(insn.getReceiver().getIndex()).append(" := cast @")
-                .append(insn.getValue().getIndex())
-                .append(" from INT to ").append(insn.getTargetType());
-    }
-
-    @Override
-    public void visit(UnwrapArrayInstruction insn) {
-        sb.append("@").append(insn.getReceiver().getIndex()).append(" := @")
-                .append(insn.getArray().getIndex()).append(".data");
-    }
-
-    @Override
-    public void visit(ArrayLengthInstruction insn) {
-        sb.append("@").append(insn.getReceiver().getIndex()).append(" := @")
-                .append(insn.getArray().getIndex()).append(".length");
-    }
-
-    @Override
-    public void visit(CloneArrayInstruction insn) {
-        sb.append("@").append(insn.getReceiver().getIndex()).append("@")
-                .append(insn.getArray().getIndex()).append(".clone()");
-    }
-
-    @Override
-    public void visit(InitClassInstruction insn) {
-        sb.append("initclass ").append(insn.getClassName());
     }
 }

teavm-core/src/main/java/org/teavm/model/util/ListingBuilder.java

@@ -23,29 +23,29 @@ import org.teavm.model.*;
  * @author Alexey Andreev
  */
 public class ListingBuilder {
-    public String buildListing(Program program, String prefix) {
+    public String buildListing(ProgramReader program, String prefix) {
         StringBuilder sb = new StringBuilder();
         InstructionStringifier stringifier = new InstructionStringifier(sb);
         for (int i = 0; i < program.basicBlockCount(); ++i) {
-            BasicBlock block = program.basicBlockAt(i);
+            BasicBlockReader block = program.basicBlockAt(i);
             sb.append(prefix).append("$").append(i).append(":\n");
-            for (Phi phi : block.getPhis()) {
+            for (PhiReader phi : block.readPhis()) {
                 sb.append(prefix).append("    ");
                 sb.append("@").append(phi.getReceiver().getIndex()).append(" := ");
-                List<Incoming> incomings = phi.getIncomings();
+                List<? extends IncomingReader> incomings = phi.readIncomings();
                 for (int j = 0; j < incomings.size(); ++j) {
                     if (j > 0) {
                         sb.append(", ");
                     }
-                    Incoming incoming = incomings.get(j);
+                    IncomingReader incoming = incomings.get(j);
                     sb.append("@").append(incoming.getValue().getIndex()).append(" from ")
                             .append("$").append(incoming.getSource().getIndex());
                 }
                 sb.append("\n");
             }
-            for (Instruction insn : block.getInstructions()) {
+            for (int j = 0; j < block.instructionCount(); ++j) {
                 sb.append(prefix).append("    ");
-                insn.acceptVisitor(stringifier);
+                block.readInstruction(j, stringifier);
                 sb.append("\n");
             }
         }

teavm-html4j/src/main/java/org/teavm/html4j/JavaScriptBodyDependency.java

@@ -48,10 +48,11 @@ public class JavaScriptBodyDependency implements DependencyListener {
     }
 
     @Override
-    public void methodAchieved(DependencyChecker dependencyChecker, MethodGraph graph) {
+    public void methodAchieved(DependencyChecker dependencyChecker, MethodDependency graph) {
-        ClassHolder cls = dependencyChecker.getClassSource().get(graph.getReference().getClassName());
+        if (graph.isMissing()) {
-        MethodHolder method = cls.getMethod(graph.getReference().getDescriptor());
+            return;
-        AnnotationReader annot = method.getAnnotations().get(JavaScriptBody.class.getName());
+        }
+        AnnotationReader annot = graph.getMethod().getAnnotations().get(JavaScriptBody.class.getName());
         if (annot != null) {
             includeDefaultDependencies(dependencyChecker);
             AnnotationValue javacall = annot.getValue("javacall");
@@ -75,12 +76,12 @@ public class JavaScriptBodyDependency implements DependencyListener {
     }
 
     private void includeDefaultDependencies(DependencyChecker dependencyChecker) {
-        dependencyChecker.attachMethodGraph(JavaScriptConvGenerator.fromJsMethod, DependencyStack.ROOT);
+        dependencyChecker.linkMethod(JavaScriptConvGenerator.fromJsMethod, DependencyStack.ROOT);
-        dependencyChecker.attachMethodGraph(JavaScriptConvGenerator.toJsMethod, DependencyStack.ROOT);
+        dependencyChecker.linkMethod(JavaScriptConvGenerator.toJsMethod, DependencyStack.ROOT);
-        dependencyChecker.attachMethodGraph(JavaScriptConvGenerator.intValueMethod, DependencyStack.ROOT);
+        dependencyChecker.linkMethod(JavaScriptConvGenerator.intValueMethod, DependencyStack.ROOT);
-        dependencyChecker.attachMethodGraph(JavaScriptConvGenerator.valueOfIntMethod, DependencyStack.ROOT);
+        dependencyChecker.linkMethod(JavaScriptConvGenerator.valueOfIntMethod, DependencyStack.ROOT);
-        dependencyChecker.attachMethodGraph(JavaScriptConvGenerator.booleanValueMethod, DependencyStack.ROOT);
+        dependencyChecker.linkMethod(JavaScriptConvGenerator.booleanValueMethod, DependencyStack.ROOT);
-        dependencyChecker.attachMethodGraph(JavaScriptConvGenerator.valueOfBooleanMethod, DependencyStack.ROOT);
+        dependencyChecker.linkMethod(JavaScriptConvGenerator.valueOfBooleanMethod, DependencyStack.ROOT);
     }
 
     @Override
@@ -114,9 +115,9 @@ public class JavaScriptBodyDependency implements DependencyListener {
     private class GeneratorJsCallback extends JsCallback {
         private ClassReaderSource classSource;
         private DependencyChecker dependencyChecker;
-        private MethodGraph caller;
+        private MethodDependency caller;
         public GeneratorJsCallback(ClassReaderSource classSource, DependencyChecker dependencyChecker,
-                MethodGraph caller) {
+                MethodDependency caller) {
             this.classSource = classSource;
             this.dependencyChecker = dependencyChecker;
             this.caller = caller;
@@ -126,13 +127,13 @@ public class JavaScriptBodyDependency implements DependencyListener {
             MethodReader reader = findMethod(classSource, fqn, desc);
             if (reader != null) {
                 if (reader.hasModifier(ElementModifier.STATIC) || reader.hasModifier(ElementModifier.FINAL)) {
-                    MethodGraph graph = dependencyChecker.attachMethodGraph(reader.getReference(), caller.getStack());
+                    MethodDependency graph = dependencyChecker.linkMethod(reader.getReference(), caller.getStack());
                     for (int i = 0; i <= graph.getParameterCount(); ++i) {
                         allClassesNode.connect(graph.getVariable(i));
                     }
                 } else {
-                    allClassesNode.addConsumer(new VirtualCallbackConsumer(classSource, dependencyChecker, desc,
+                    allClassesNode.addConsumer(new VirtualCallbackConsumer(dependencyChecker,
-                            caller));
+                            reader.getReference(), caller));
                 }
             }
             return "";
@@ -140,24 +141,21 @@ public class JavaScriptBodyDependency implements DependencyListener {
     }
 
     private class VirtualCallbackConsumer implements DependencyConsumer {
-        private ClassReaderSource classSource;
+        private String superClass;
         private DependencyChecker dependencyChecker;
-        private MethodDescriptor desc;
+        private MethodReference superMethod;
-        private MethodGraph caller;
+        private MethodDependency caller;
-        public VirtualCallbackConsumer(ClassReaderSource classSource, DependencyChecker dependencyChecker,
+        public VirtualCallbackConsumer(DependencyChecker dependencyChecker, MethodReference superMethod,
-                MethodDescriptor desc, MethodGraph caller) {
+                MethodDependency caller) {
-            this.classSource = classSource;
             this.dependencyChecker = dependencyChecker;
-            this.desc = desc;
+            this.superMethod = superMethod;
             this.caller = caller;
         }
         @Override public void consume(String type) {
-            MethodReader reader = findMethod(classSource, type, desc);
+            MethodReference method = new MethodReference(type, superMethod.getDescriptor());
-            if (reader != null) {
+            MethodDependency graph = dependencyChecker.linkMethod(method, caller.getStack());
-                MethodGraph graph = dependencyChecker.attachMethodGraph(reader.getReference(), caller.getStack());
+            for (int i = 0; i < graph.getParameterCount(); ++i) {
-                for (int i = 0; i < graph.getParameterCount(); ++i) {
+                allClassesNode.connect(graph.getVariable(i));
-                    allClassesNode.connect(graph.getVariable(i));
-                }
             }
         }
     }

teavm-html4j/src/test/java/net/java/html/js/tests/JavaScriptBodyTests.java

@@ -317,15 +317,15 @@ public class JavaScriptBodyTests {
 
     private static class R implements Runnable {
         int cnt;
-        //private final Thread initThread;
+        private final Thread initThread;
 
         public R() {
-            //initThread = Thread.currentThread();
+            initThread = Thread.currentThread();
         }
 
         @Override
         public void run() {
-            //assert initThread == Thread.currentThread() : "Expecting to run in " + initThread + " but running in " + Thread.currentThread();
+            assert initThread == Thread.currentThread() : "Expecting to run in " + initThread + " but running in " + Thread.currentThread();
             cnt++;
         }
     }

teavm-jso/src/main/java/org/teavm/javascript/ni/JSNativeGenerator.java

@@ -20,14 +20,11 @@ import org.teavm.codegen.SourceWriter;
 import org.teavm.dependency.DependencyChecker;
 import org.teavm.dependency.DependencyConsumer;
 import org.teavm.dependency.DependencyPlugin;
-import org.teavm.dependency.MethodGraph;
+import org.teavm.dependency.MethodDependency;
 import org.teavm.javascript.ast.ConstantExpr;
 import org.teavm.javascript.ast.Expr;
 import org.teavm.javascript.ast.InvocationExpr;
-import org.teavm.model.ClassHolder;
+import org.teavm.model.*;
-import org.teavm.model.FieldReference;
-import org.teavm.model.MethodHolder;
-import org.teavm.model.MethodReference;
 
 /**
  *
@@ -97,7 +94,7 @@ public class JSNativeGenerator implements Generator, Injector, DependencyPlugin
     }
 
     @Override
-    public void methodAchieved(final DependencyChecker checker, final MethodGraph graph) {
+    public void methodAchieved(final DependencyChecker checker, final MethodDependency graph) {
         for (int i = 0; i < graph.getReference().parameterCount(); ++i) {
             graph.getVariable(i).addConsumer(new DependencyConsumer() {
                 @Override public void consume(String type) {
@@ -107,11 +104,14 @@ public class JSNativeGenerator implements Generator, Injector, DependencyPlugin
         }
     }
 
-    private void achieveFunctorMethods(DependencyChecker checker, String type, MethodGraph caller) {
+    private void achieveFunctorMethods(DependencyChecker checker, String type, MethodDependency caller) {
-        ClassHolder cls = checker.getClassSource().get(type);
+        if (caller.isMissing()) {
+            return;
+        }
+        ClassReader cls = checker.getClassSource().get(type);
         if (cls != null) {
-            for (MethodHolder method : cls.getMethods()) {
+            for (MethodReader method : cls.getMethods()) {
-                checker.attachMethodGraph(method.getReference(), caller.getStack());
+                checker.linkMethod(method.getReference(), caller.getStack());
             }
         }
     }