public String signatureToString() { return getDescriptor().signatureToString(); } }
@Override @JsonValue public String toString() { if (reprCache == null) { reprCache = className + "." + getDescriptor().toString(); } return reprCache; }
private void collectMethodsToCopyFromInterfaces(ClassReader cls, List<MethodReference> targetList) { Set<MethodDescriptor> implementedMethods = new HashSet<>(); implementedMethods.addAll(targetList.stream().map(method -> method.getDescriptor()) .collect(Collectors.toList())); Set<String> visitedClasses = new HashSet<>(); for (String ifaceName : cls.getInterfaces()) { ClassReader iface = classSource.get(ifaceName); if (iface != null) { collectMethodsToCopyFromInterfacesImpl(iface, targetList, implementedMethods, visitedClasses); } } }
default MethodReader resolve(MethodReference method) { return getAncestors(method.getClassName()) .map(cls -> cls.getMethod(method.getDescriptor())) .filter(Objects::nonNull) .findFirst().orElse(null); }
@Override public boolean isApplicable(MethodReference methodReference) { return methodReference.getClassName().equals("java.lang.Class") && isApplicableToMethod(methodReference.getDescriptor()); }
@Override public boolean isApplicable(MethodReference methodReference) { return methodReference.getClassName().equals(PLATFORM) && isApplicableToMethod(methodReference.getDescriptor()); }
private void getFunctorMethods(String className, Map<MethodDescriptor, MethodReference> methods) { classSource.getAncestors(className).forEach(cls -> { if (cls.getAnnotations().get(JSFunctor.class.getName()) != null && marshaller.isProperFunctor(cls)) { MethodReference method = cls.getMethods().iterator().next().getReference(); if (!methods.containsKey(method.getDescriptor())) { methods.put(method.getDescriptor(), method); } } }); }
private File getMethodFile(MethodReference method, boolean async) { File dir = new File(directory, method.getClassName().replace('.', '/')); return new File(dir, FileNameEncoder.encodeFileName(method.getDescriptor().toString()) + ".teavm-ast" + (async ? "-async" : "")); }
default Stream<MethodReader> overriddenMethods(MethodReference method) { return getAncestorClasses(method.getClassName()) .map(cls -> cls.getMethod(method.getDescriptor())) .filter(Objects::nonNull); }
public VirtualTableEntry lookup(MethodReference method) { VirtualTable vtable = virtualTables.get(interfaceMapping.mapClass(method.getClassName())); if (vtable == null) { return null; } return vtable.getEntries().get(method.getDescriptor()); }
public static MethodHandle interfaceCaller(MethodReference method) { return interfaceCaller(method.getClassName(), method.getDescriptor()); } }
private void addOverriddenToFamily(MethodReference methodRef) { asyncFamilyMethods.put(methodRef, true); ClassReader cls = classSource.get(methodRef.getClassName()); if (cls == null) { return; } for (MethodReference overriddenMethod : findOverriddenMethods(cls, methodRef.getDescriptor())) { addOverriddenToFamily(overriddenMethod); } }
FastVirtualCallConsumer getVirtualCallConsumer(MethodReference method) { return virtualCallConsumers.computeIfAbsent(method, key -> { FastVirtualCallConsumer consumer = new FastVirtualCallConsumer(instancesNode, key.getDescriptor(), this); defer(() -> { getSubtypeNode(method.getClassName()).addConsumer(consumer); }); return consumer; }); }
@Override public MethodDependency getMethodImplementation(MethodReference methodRef) { MethodReader method = getMethodHolder(methodRef.getClassName(), methodRef.getDescriptor()); return method != null ? getMethod(method.getReference()) : null; }
@Override public String getStaticMethodAlias(MethodReference method) { String alias = method.getDescriptor().getName(); switch (alias) { case "<init>": alias = "_init_"; break; case "<clinit>": alias = "_clinit_"; break; } return makeUnique(knownAliases, knowAliasesCounter, getClassAlias(method.getClassName()) + "_" + alias); }
private void addFunctorField(ClassHolder cls, MethodReference method) { if (cls.getAnnotations().get(FunctorImpl.class.getName()) != null) { return; } FieldHolder field = new FieldHolder("$$jso_functor$$"); field.setLevel(AccessLevel.PUBLIC); field.setType(ValueType.parse(JSObject.class)); cls.addField(field); AnnotationHolder annot = new AnnotationHolder(FunctorImpl.class.getName()); annot.getValues().put("value", new AnnotationValue(method.getDescriptor().toString())); cls.getAnnotations().add(annot); }
@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; } }
public void addEntryPoint(MethodReference methodRef, String... argumentTypes) { ValueType[] parameters = methodRef.getDescriptor().getParameterTypes(); if (parameters.length + 1 != argumentTypes.length) { throw new IllegalArgumentException("argumentTypes length does not match the number of method's arguments"); } MethodDependency method = linkMethod(methodRef); method.use(); DependencyNode[] varNodes = method.getVariables(); varNodes[0].propagate(getType(methodRef.getClassName())); for (int i = 0; i < argumentTypes.length; ++i) { varNodes[i + 1].propagate(getType(argumentTypes[i])); } }
public void generateMethodSignature(CodeWriter writer, MethodReference methodRef, boolean isStatic, boolean withNames) { writer.print("static "); writer.printType(methodRef.getReturnType()).print(" ").print(names.forMethod(methodRef)).print("("); generateMethodParameters(writer, methodRef.getDescriptor(), isStatic, withNames); writer.print(")"); }
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(); } }