public CodeTreeBuilder startCall(String callSite) { return startCall((CodeTree) null, callSite); }
public CodeTreeBuilder startCall(String callSite) { return startCall((CodeTree) null, callSite); }
private static CodeTree callMethod(CodeTree receiver, ExecutableElement method, CodeTree... boundValues) { CodeTreeBuilder builder = CodeTreeBuilder.createBuilder(); if (method.getModifiers().contains(STATIC)) { builder.startStaticCall(method.getEnclosingElement().asType(), method.getSimpleName().toString()); } else { builder.startCall(receiver, method.getSimpleName().toString()); } int index = -1; for (VariableElement parameter : method.getParameters()) { index++; if (index < boundValues.length) { CodeTree tree = boundValues[index]; if (tree != null) { builder.tree(tree); continue; } } builder.defaultValue(parameter.asType()); } builder.end(); return builder.build(); }
private static CodeTree createBuildOptionDescriptor(ProcessorContext context, OptionInfo info) { CodeTreeBuilder builder = CodeTreeBuilder.createBuilder(); builder.startStaticCall(context.getType(OptionDescriptor.class), "newBuilder"); VariableElement var = info.field; builder.staticReference(var.getEnclosingElement().asType(), var.getSimpleName().toString()); builder.doubleQuote(info.name); builder.end(); // newBuilder call if (info.deprecated) { builder.startCall("", "deprecated").string("true").end(); } else { builder.startCall("", "deprecated").string("false").end(); } builder.startCall("", "help").doubleQuote(info.help).end(); builder.startCall("", "category").staticReference(context.getType(OptionCategory.class), info.category.name()).end(); builder.startCall("", "build").end(); return builder.build(); }
public static CodeTree cast(String nodeName, CodeTree value) { return CodeTreeBuilder.createBuilder().startCall(nodeName, "cast").tree(value).end().build(); }
public static CodeTree check(String nodeName, CodeTree value) { return CodeTreeBuilder.createBuilder().startCall(nodeName, "check").tree(value).end().build(); }
private CodeTree createThrowUnsupported(LocalContext currentValues) { singleSpecializableUnsupportedUsed = true; CodeTreeBuilder builder = CodeTreeBuilder.createBuilder(); builder.startThrow().startCall("unsupported"); currentValues.addReferencesTo(builder); builder.end().end(); return builder.build(); }
private CodeTree createAssumptionGuard(AssumptionExpression assumption, CodeTree assumptionValue) { CodeTree assumptionGuard = CodeTreeBuilder.createBuilder().startCall("isValid_").tree(assumptionValue).end().build(); isValidSignatures.put(ElementUtils.getQualifiedName(assumption.getExpression().getResolvedType()), assumption.getExpression().getResolvedType()); return assumptionGuard; }
private CodeTree createCallDelegate(String methodName, String reason, ExecutableTypeData forType, LocalContext currentValues) { CodeTreeBuilder builder = CodeTreeBuilder.createBuilder(); builder.startCall(methodName); if (reason != null) { builder.doubleQuote(reason); } currentValues.addReferencesTo(builder, FRAME_VALUE); builder.end(); CodeTree expectOrCast = expectOrCast(genericType, forType, builder.build()); return expectOrCast; }
private CodeTree wrapInAMethod(CodeTreeBuilder parent, SpecializationGroup group, FrameState frameState, String suffix, CodeTree codeTree) { CodeExecutableElement parentMethod = (CodeExecutableElement) parent.findMethod(); CodeTypeElement parentClass = (CodeTypeElement) parentMethod.getEnclosingElement(); String name = parentMethod.getSimpleName().toString() + "_" + suffix + (boxingSplitIndex++); CodeExecutableElement method = parentClass.add( frameState.createMethod(modifiers(Modifier.PRIVATE), parentMethod.getReturnType(), name, FRAME_VALUE, STATE_VALUE)); CodeTreeBuilder builder = method.createBuilder(); builder.tree(codeTree); method.getThrownTypes().addAll(parentMethod.getThrownTypes()); addExplodeLoop(builder, group); CodeTreeBuilder parentBuilder = parent.create(); parentBuilder.startReturn(); parentBuilder.startCall(method.getSimpleName().toString()); frameState.addReferencesTo(parentBuilder, FRAME_VALUE, STATE_VALUE); parentBuilder.end(); parentBuilder.end(); return parentBuilder.build(); }
private Element createGetCostMethod() { TypeMirror returnType = getType(NodeCost.class); CodeExecutableElement executable = new CodeExecutableElement(modifiers(PUBLIC), returnType, "getCost"); executable.getAnnotationMirrors().add(new CodeAnnotationMirror(context.getDeclaredType(Override.class))); CodeTreeBuilder builder = executable.createBuilder(); if (singleSpecializable) { builder.startReturn().staticReference(getType(NodeCost.class), "MONOMORPHIC").end().end(); } else { builder.startReturn().startCall(specializationStartFieldName(), "getNodeCost").end().end(); } return executable; }
private CodeExecutableElement createFallbackGuardMethod() { boolean frameUsed = node.isFrameUsedByAnyGuard(); LocalContext locals = LocalContext.load(this); if (!frameUsed) { locals.removeValue(FRAME_VALUE); } CodeExecutableElement boundaryMethod = locals.createMethod(modifiers(PRIVATE), getType(boolean.class), "guardFallback", varArgsThreshold, FRAME_VALUE); if (!frameUsed) { boundaryMethod.getAnnotationMirrors().add(new CodeAnnotationMirror(context.getDeclaredType(TruffleBoundary.class))); } CodeTreeBuilder builder = boundaryMethod.createBuilder(); builder.startReturn(); builder.startCall("createNext"); locals.addReferencesTo(builder, FRAME_VALUE); builder.end(); builder.string(" == null"); builder.end(); return boundaryMethod; }
static CodeTree expect(TypeSystemData typeSystem, TypeMirror type, CodeTree content) { if (ElementUtils.isObject(type) || ElementUtils.isVoid(type)) { return content; } CodeTreeBuilder builder = CodeTreeBuilder.createBuilder(); if (typeSystem.hasType(type)) { builder.startStaticCall(createTypeSystemGen(typeSystem), expectTypeMethodName(typeSystem, type)).tree(content).end(); } else { builder.startCall(expectTypeMethodName(typeSystem, type)).tree(content).end(); } return builder.build(); }
public static CodeTree expect(TypeSystemData typeSystem, TypeMirror type, CodeTree content) { if (ElementUtils.isObject(type) || ElementUtils.isVoid(type)) { return content; } CodeTreeBuilder builder = CodeTreeBuilder.createBuilder(); if (typeSystem.hasType(type)) { builder.startStaticCall(createTypeSystemGen(typeSystem), expectTypeMethodName(typeSystem, type)).tree(content).end(); } else { builder.startCall(expectTypeMethodName(typeSystem, type)).tree(content).end(); } return builder.build(); }
private CodeTree createCallRemove(String reason, ExecutableTypeData forType, LocalContext currentValues) { if (singleSpecializable) { return createThrowUnsupported(currentValues); } CodeTreeBuilder builder = CodeTreeBuilder.createBuilder(); builder.startCall("remove"); builder.doubleQuote(reason); currentValues.addReferencesTo(builder, FRAME_VALUE); builder.end(); CodeTree call = builder.build(); builder = builder.create(); builder.startReturn(); builder.tree(expectOrCast(genericType, forType, call)); builder.end(); return builder.build(); }
private CodeTree createReturnUnexpectedResult(ExecutableTypeData forType, boolean needsCast) { TypeMirror returnType = context.getType(Object.class); CodeTreeBuilder builder = CodeTreeBuilder.createBuilder(); builder.startCall(needsCast ? "((UnexpectedResultException) ex)" : "ex", "getResult").end(); CodeTree call = builder.build(); builder = builder.create(); if (isVoid(forType.getReturnType())) { builder.statement(call); builder.returnStatement(); } else { builder.startReturn(); builder.tree(expectOrCast(returnType, forType, call)); builder.end(); } return builder.build(); }
private CodeTree createFastPathAssumptionCheck(CodeTreeBuilder parent, SpecializationData specialization, ExecutableTypeData forType, FrameState frameState) throws AssertionError { CodeTreeBuilder builder = parent.create(); builder.startIf(); String sep = ""; for (AssumptionExpression assumption : specialization.getAssumptionExpressions()) { builder.string(sep); builder.string("!"); builder.startCall("isValid_").tree(createAssumptionReference(frameState, specialization, assumption)).end(); isValidSignatures.put(ElementUtils.getQualifiedName(assumption.getExpression().getResolvedType()), assumption.getExpression().getResolvedType()); sep = " || "; } builder.end().startBlock(); builder.tree(createTransferToInterpreterAndInvalidate()); builder.tree(createRemoveThis(builder, frameState, forType, specialization)); builder.end(); return builder.build(); }
private CodeTree createFastPathExecute(CodeTreeBuilder parent, final ExecutableTypeData forType, SpecializationData specialization, FrameState frameState) { CodeTreeBuilder builder = parent.create(); int ifCount = 0; if (specialization.isFallback()) { builder.startIf().startCall(METHOD_FALLBACK_GUARD); if (fallbackNeedsFrame) { if (frameState.get(FRAME_VALUE) != null) { builder.string(FRAME_VALUE); } else { builder.nullLiteral(); } } if (fallbackNeedsState) { builder.string(STATE_VALUE); } frameState.addReferencesTo(builder); builder.end(); builder.end(); builder.startBlock(); ifCount++; } builder.tree(createExecute(builder, frameState, forType, specialization, NodeExecutionMode.FAST_PATH)); builder.end(ifCount); return builder.build(); }