public CodeTreeBuilder cast(TypeMirror type, CodeTree content) { if (ElementUtils.isVoid(type)) { tree(content); return this; } else if (type.getKind() == TypeKind.DECLARED && ElementUtils.getQualifiedName(type).equals("java.lang.Object")) { tree(content); return this; } else { return startGroup().string("(").type(type).string(")").string(" ").tree(content).end(); } }
public CodeTreeBuilder appendBuilder() { CodeTreeBuilder builder = new CodeTreeBuilder(null); builder.setEnclosingElement(this); if (bodyTree != null) { builder.tree(bodyTree); } this.bodyTree = builder.getTree(); this.body = null; return builder; }
private static CodeTree createShortCircuit(LocalVariable targetValue, LocalVariable shortCircuitValue, CodeTree tryExecute) { if (shortCircuitValue == null) { return tryExecute; } CodeTreeBuilder builder = CodeTreeBuilder.createBuilder(); builder.tree(shortCircuitValue.createDeclaration(shortCircuitValue.createReference())); builder.tree(targetValue.createDeclaration(builder.create().defaultValue(targetValue.getTypeMirror()).build())); builder.startIf().string(shortCircuitValue.getName()).end().startBlock(); builder.tree(tryExecute); builder.end(); return builder.build(); }
private CodeTree createCallNext(CodeTreeBuilder parent, ExecutableTypeData currentType, ExecutableTypeData callType, LocalContext currentValues) { if (singleSpecializable) { return createThrowUnsupported(currentValues); } CodeTreeBuilder callBuilder = parent.create(); callBuilder.tree(createCallDelegateExecute(callBuilder, CodeTreeBuilder.singleString("getNext()"), currentValues, currentType, callType)); nextUsed = true; return callBuilder.build(); }
public CodeTree createIsNotAny(FrameState frameState, Object[] elements) { CodeTreeBuilder builder = CodeTreeBuilder.createBuilder(); builder.tree(createMaskedReference(frameState, elements)); builder.string(" != 0 "); builder.string(" /* is-not ", toString(elements, " && "), " */"); return builder.build(); }
public CodeTreeBuilder declaration(String type, String name, CodeTree init) { startStatement(); string(type); string(" "); string(name); if (init != null) { string(" = "); tree(init); } end(); // statement return this; }
static CodeTree invokeImplicitCast(TypeSystemData typeSystem, ImplicitCastData cast, CodeTree expression) { CodeTreeBuilder builder = CodeTreeBuilder.createBuilder(); builder.startStaticCall(createTypeSystemGen(typeSystem), cast.getMethodName()).tree(expression); builder.end(); return builder.build(); }
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 Element createCreatePolymorphic(Map<SpecializationData, CodeTypeElement> generatedSpecializationClasses) { SpecializationData polymorphic = node.getPolymorphicSpecialization(); CodeTypeElement generatedPolymorphic = generatedSpecializationClasses.get(polymorphic); if (generatedPolymorphic == null) { return null; } TypeMirror returnType = getType(SpecializationNode.class); CodeExecutableElement method = new CodeExecutableElement(modifiers(PROTECTED, FINAL), returnType, "createPolymorphic"); method.getAnnotationMirrors().add(new CodeAnnotationMirror(context.getDeclaredType(Override.class))); method.createBuilder().startReturn().tree(createCallCreateMethod(polymorphic, null, null)).end(); return method; }
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 Element createAcceptAndExecute() { ExecutableTypeData executableElement = createSpecializationNodeSignature(node.getSignatureSize()); LocalContext currentLocals = LocalContext.load(this, executableElement, varArgsThreshold); CodeExecutableElement executable = createExecuteMethod(null, executableElement, currentLocals, false, varArgsThreshold); executable.getModifiers().add(FINAL); CodeTreeBuilder builder = executable.createBuilder(); CodeTree receiver = CodeTreeBuilder.singleString("this"); builder.tree(createCallDelegateExecute(builder, receiver, currentLocals, executableElement, node.getGenericExecutableType(null))); return executable; }
private Element createGetSuppliedChildrenMethod() { ArrayType nodeArray = context.getEnvironment().getTypeUtils().getArrayType(getType(Node.class)); CodeExecutableElement method = new CodeExecutableElement(modifiers(PROTECTED, FINAL), nodeArray, "getSuppliedChildren"); method.getAnnotationMirrors().add(new CodeAnnotationMirror(context.getDeclaredType(Override.class))); CodeTreeBuilder builder = method.createBuilder(); builder.startReturn().tree(createGetSuppliedChildren()).end(); return method; }
public CodeTree createIs(FrameState frameState, Object[] selectedElements, Object[] maskedElements) { CodeTreeBuilder builder = CodeTreeBuilder.createBuilder(); builder.tree(createMaskedReference(frameState, maskedElements)); builder.string(" == ").string(formatMask(createMask(selectedElements))); return builder.build(); }
public CodeTree createContains(FrameState frameState, Object[] elements) { CodeTreeBuilder builder = CodeTreeBuilder.createBuilder(); builder.tree(createMaskedReference(frameState, elements)); builder.string(" != 0"); builder.string(" /* ", label("is"), toString(elements, " || "), " */"); return builder.build(); }
public static CodeTree check(TypeSystemData typeSystem, TypeMirror type, CodeTree content) { if (ElementUtils.isObject(type)) { return content; } CodeTreeBuilder builder = CodeTreeBuilder.createBuilder(); TypeCheckData check = typeSystem.getCheck(type); if (check == null) { builder.instanceOf(content, ElementUtils.boxType(typeSystem.getContext(), type)); } else { builder.startStaticCall(typeSystem.getTemplateType().asType(), check.getMethodName()).tree(content).end(); } return builder.build(); }
public CodeTreeBuilder startNewArray(ArrayType arrayType, CodeTree size) { startGroup().string("new ").type(arrayType.getComponentType()).string("["); if (size != null) { tree(size); } string("]"); if (size == null) { string(" "); startCurlyBracesCommaGroup().endAfter(); } return this; }
public CodeTree createNotContains(FrameState frameState, Object[] elements) { CodeTreeBuilder builder = CodeTreeBuilder.createBuilder(); builder.startParantheses(); builder.tree(createMaskedReference(frameState, elements)); builder.end(); builder.string(" == 0"); builder.string(" /* ", label("is-not"), toString(elements, " && "), " */"); return builder.build(); }
public CodeTreeBuilder startCall(CodeTree receiver, String callSite) { if (receiver == null) { return startGroup().string(callSite).startParanthesesCommaGroup().endAfter(); } else { return startGroup().tree(receiver).string(".").string(callSite).startParanthesesCommaGroup().endAfter(); } }
private CodeExecutableElement createAsTypeMethod(TypeMirror type) { if (typeSystem.getCast(type) != null) { return null; } CodeExecutableElement method = new CodeExecutableElement(modifiers(PUBLIC, STATIC), type, TypeSystemCodeGenerator.asTypeMethodName(typeSystem, type)); method.addParameter(new CodeVariableElement(context.getType(Object.class), LOCAL_VALUE)); CodeTreeBuilder body = method.createBuilder(); String assertMessage = typeName(typeSystem) + "." + asTypeMethodName(typeSystem, type) + ": " + ElementUtils.getSimpleName(type) + " expected"; body.startAssert().tree(check(typeSystem, type, LOCAL_VALUE)).string(" : ").doubleQuote(assertMessage).end(); body.startReturn().tree(cast(typeSystem, type, LOCAL_VALUE)).end(); return method; }
private CodeExecutableElement createIsTypeMethod(TypeMirror type) { if (typeSystem.getCheck(type) != null) { return null; } CodeExecutableElement method = new CodeExecutableElement(modifiers(PUBLIC, STATIC), context.getType(boolean.class), TypeSystemCodeGenerator.isTypeMethodName(typeSystem, type)); method.addParameter(new CodeVariableElement(context.getType(Object.class), LOCAL_VALUE)); CodeTreeBuilder body = method.createBuilder(); body.startReturn().tree(check(typeSystem, type, LOCAL_VALUE)).end(); return method; }