@Override public void add(MethodReference methodRef, BootstrapMethodSubstitutor substitutor) { dependencyAnalyzer.addBootstrapMethodSubstitutor(methodRef, substitutor); }
@Override public void add(ClassHolderTransformer transformer) { dependencyAnalyzer.addClassTransformer(transformer); }
@Override public void add(DependencyListener listener) { dependencyAnalyzer.addDependencyListener(listener); }
public MethodDependency linkMethod(String className, MethodDescriptor descriptor) { MethodDependency dep = getMethodDependency(className, descriptor); if (!dep.activated) { reachedMethods.add(dep.getReference()); dep.activated = true; if (!dep.isMissing()) { for (DependencyListener listener : listeners) { listener.methodReached(agent, dep); } activateDependencyPlugin(dep); } } return dep; }
TeaVM(TeaVMBuilder builder) { target = builder.target; classSource = builder.classSource; classLoader = builder.classLoader; dependencyAnalyzer = builder.dependencyAnalyzerFactory.create(this.classSource, classLoader, this, diagnostics); progressListener = new TeaVMProgressListener() { @Override public TeaVMProgressFeedback progressReached(int progress) { return TeaVMProgressFeedback.CONTINUE; } @Override public TeaVMProgressFeedback phaseStarted(TeaVMPhase phase, int count) { return TeaVMProgressFeedback.CONTINUE; } }; for (ClassHolderTransformer transformer : target.getTransformers()) { dependencyAnalyzer.addClassTransformer(transformer); } for (DependencyListener listener : target.getDependencyListeners()) { dependencyAnalyzer.addDependencyListener(listener); } for (TeaVMHostExtension extension : target.getHostExtensions()) { for (Class<?> extensionType : getExtensionTypes(extension)) { extensions.put(extensionType, extension); } } }
private ListableClassHolderSource eagerPipeline() { compileProgressValue = 0; compileProgressLimit = dependencyAnalyzer.getReachableClasses().size(); if (optimizationLevel == TeaVMOptimizationLevel.ADVANCED) { compileProgressLimit *= 3; dependencyAnalyzer.cleanupTypes();
DependencyAnalyzer(ClassReaderSource classSource, ClassLoader classLoader, ServiceRepository services, Diagnostics diagnostics) { unprocessedClassSource = classSource; this.diagnostics = diagnostics; this.classSource = new DependencyClassSource(classSource, diagnostics, incrementalCache); classHierarchy = new ClassHierarchy(this.classSource); this.classLoader = classLoader; this.services = services; fieldReaderCache = new CachedMapper<>(preimage -> this.classSource.resolveMutable(preimage)); fieldCache = new CachedMapper<>(preimage -> { FieldReader field = fieldReaderCache.map(preimage); if (field != null && !field.getReference().equals(preimage)) { return fieldCache.map(field.getReference()); } FieldDependency node = createFieldNode(preimage, field); if (field != null && field.getInitialValue() instanceof String) { node.getValue().propagate(getType("java.lang.String")); } return node; }); classCache = new CachedMapper<>(this::createClassDependency); agent = new DependencyAgent(this); }
@Override public DependencyNode getArrayItem() { if (arrayItemNode == null) { arrayItemNode = dependencyAnalyzer.createArrayItemNode(this); } return arrayItemNode; }
@Override public DependencyNode getClassValueNode() { if (classValueNode == null) { classValueNode = dependencyAnalyzer.createClassValueNode(degree, this); } return classValueNode; }
@Override public void add(MethodReference methodRef, DependencyPlugin dependencyPlugin) { dependencyAnalyzer.addDependencyPlugin(methodRef, dependencyPlugin); }
private void activateDependencyPlugin(MethodDependency methodDep) { attachDependencyPlugin(methodDep); if (methodDep.dependencyPlugin != null) { methodDep.dependencyPlugin.methodReached(agent, methodDep); } }
private FieldDependency createFieldNode(FieldReference fieldRef, FieldReader field) { DependencyNode node = createFieldNode(fieldRef, field != null ? field.getType() : null); return new FieldDependency(node, field, fieldRef); }