private MethodReader findOverriddenMethod(String className, MethodReader finalMethod) { if (finalMethod.getName().equals("<init>")) { return null; } return classSource.getAncestors(className) .skip(1) .map(cls -> cls.getMethod(finalMethod.getDescriptor())) .filter(Objects::nonNull) .findFirst() .orElse(null); }
private ReflectMethodImpl getDeclaredMethod(MethodDescriptor method) { resolve(); return methods.computeIfAbsent(method, m -> { MethodReader methodReader = classReader.getMethod(m); return methodReader != null ? new ReflectMethodImpl(this, methodReader) : null; }); }
default MethodReader resolve(MethodReference method) { return getAncestors(method.getClassName()) .map(cls -> cls.getMethod(method.getDescriptor())) .filter(Objects::nonNull) .findFirst().orElse(null); }
private boolean clinitNeeded(String className) { ClassReader cls = unprocessedClassSource.get(className); if (cls == null) { return true; } return cls.getMethod(new MethodDescriptor("<clinit>", void.class)) != null; }
public boolean hasClinit(String className) { if (isStructure(className) || className.equals(Address.class.getName())) { return false; } ClassReader cls = classSource.get(className); if (cls == null) { return false; } return cls.getMethod(new MethodDescriptor("<clinit>", ValueType.VOID)) != null; }
default Stream<MethodReader> overriddenMethods(MethodReference method) { return getAncestorClasses(method.getClassName()) .map(cls -> cls.getMethod(method.getDescriptor())) .filter(Objects::nonNull); }
private boolean isSplittingClassInitializer(String className) { ClassReader cls = classSource.get(className); if (cls == null) { return false; } MethodReader method = cls.getMethod(new MethodDescriptor("<clinit>", ValueType.VOID)); return method != null && asyncMethods.contains(method.getReference()); }
private MethodReader getMethod(MethodReference methodRef) { ClassReader cls = classes.get(methodRef.getClassName()); return cls != null ? cls.getMethod(methodRef.getDescriptor()) : null; }
void initClass(ClassDependency cls, CallLocation location) { ClassReader reader = cls.getClassReader(); MethodReader method = reader.getMethod(CLINIT_METHOD); if (method != null) { deferredTasks.add(() -> { MethodDependency initMethod = linkMethod(method.getReference()); if (location != null) { initMethod.addLocation(location); } initMethod.use(); }); } }
private void insertClinit(DependencyInfo dependency, String className, MethodReference method, Instruction insn) { if (className.equals(method.getClassName())) { return; } ClassReader cls = dependency.getClassSource().get(className); if (cls == null || cls.getMethod(clinitDescriptor) != null) { InitClassInstruction initInsn = new InitClassInstruction(); initInsn.setClassName(className); initInsn.setLocation(insn.getLocation()); insn.insertPrevious(initInsn); } } }
private MethodReference findRealMethod(MethodReference method) { String clsName = method.getClassName(); while (clsName != null) { ClassReader cls = classSource.get(clsName); if (cls == null) { break; } MethodReader methodReader = cls.getMethod(method.getDescriptor()); if (methodReader != null) { return new MethodReference(clsName, method.getDescriptor()); } clsName = cls.getParent(); if (clsName != null && clsName.equals(cls.getName())) { break; } } return method; }
@Override public boolean isVirtual(VirtualMethodContributorContext context, MethodReference methodRef) { ClassReader classReader = context.getClassSource().get(methodRef.getClassName()); if (classReader == null) { return false; } if (getFunctorField(classReader) != null) { return true; } MethodReader methodReader = classReader.getMethod(methodRef.getDescriptor()); return methodReader != null && getPublicAlias(methodReader) != null; } }
@Override public void classReached(DependencyAgent agent, String className) { ClassReader cls = agent.getClassSource().get(className); if (cls == null) { return; } if (cls.hasModifier(ElementModifier.ABSTRACT) || cls.hasModifier(ElementModifier.INTERFACE)) { return; } MethodReader method = cls.getMethod(INIT_METHOD); if (method != null) { allClassesNode.propagate(agent.getType(className)); } }
private boolean needsInitializer(ClassReader cls) { return !context.getCharacteristics().isStaticInit(cls.getName()) && !context.getCharacteristics().isStructure(cls.getName()) && cls.getMethod(new MethodDescriptor("<clinit>", ValueType.VOID)) != null; }
@Override public T apply(ProviderContext providerContext) { ClassReaderSource classSource = providerContext.getClassSource(); MethodReference methodRef = providerContext.getMethod(); ClassReader cls = classSource.get(methodRef.getClassName()); if (cls == null) { return null; } MethodReader method = cls.getMethod(methodRef.getDescriptor()); if (method == null) { return null; } return method.getAnnotations().get(annotationName) != null ? generator : null; } }
public void apply(MethodReader method, Program program) { ClassReader cls = classes.get(method.getOwnerName()); boolean hasClinit = cls.getMethod(clinitDescriptor) != null; if (needsClinitCall(method) && hasClinit) { BasicBlock entryBlock = program.basicBlockAt(0); InitClassInstruction initInsn = new InitClassInstruction(); initInsn.setClassName(method.getOwnerName()); entryBlock.addFirst(initInsn); } }
private void renderRuntimeIntern() throws IOException { writer.append("function $rt_intern(str) {").indent().softNewLine(); ClassReader stringCls = classSource.get(STRING_CLASS); if (stringCls != null && stringCls.getMethod(STRING_INTERN_METHOD) != null) { writer.append("return ").appendMethodBody(new MethodReference(STRING_CLASS, STRING_INTERN_METHOD)) .append("(str);").softNewLine(); } else { writer.append("return str;").softNewLine(); } writer.outdent().append("}").newLine(); }
private void generateStaticInitializerCalls(GenerationContext context, CodeWriter writer, ListableClassReaderSource classes) { MethodDescriptor clinitDescriptor = new MethodDescriptor("<clinit>", ValueType.VOID); for (String className : classes.getClassNames()) { ClassReader cls = classes.get(className); if (!context.getCharacteristics().isStaticInit(cls.getName()) && !context.getCharacteristics().isStructure(cls.getName())) { continue; } if (cls.getMethod(clinitDescriptor) == null) { continue; } String clinitName = context.getNames().forMethod(new MethodReference(className, clinitDescriptor)); writer.println(clinitName + "();"); } }
private void renderSetStackTrace() throws IOException { ClassReader cls = classSource.get(SET_STACK_TRACE_METHOD.getClassName()); boolean supported = cls != null && cls.getMethod(SET_STACK_TRACE_METHOD.getDescriptor()) != null; writer.append("function $rt_setStack(e,").ws().append("stack)").ws().append("{").indent().softNewLine(); if (supported) { writer.appendMethodBody(SET_STACK_TRACE_METHOD); writer.append("(e,").ws().append("stack);").softNewLine(); } writer.outdent().append("}").newLine(); } }
private void generatePrepareNewInstance(GeneratorContext context, SourceWriter writer) throws IOException { writer.append("var c").ws().append("=").ws().append("'$$constructor$$';").softNewLine(); for (String clsName : context.getClassSource().getClassNames()) { ClassReader cls = context.getClassSource().get(clsName); MethodReader method = cls.getMethod(new MethodDescriptor("<init>", void.class)); if (method != null) { writer.appendClass(clsName).append("[c]").ws().append("=").ws() .appendMethodBody(method.getReference()).append(";").softNewLine(); } } }