private static CodeTree combine(CodeTree tree1, CodeTree tree2, CodeTree tree3) { return new CodeTreeBuilder(null).startGroup().tree(tree1).tree(tree2).tree(tree3).end().build(); }
public CodeTree getTree() { assertRoot(); return root; }
public CodeTreeBuilder startElseIf() { clearLast(CodeTreeKind.NEW_LINE); return startGroup().string(" else if ").startParanthesesCommaGroup().endAndWhitespaceAfter().startGroup().endAfter(); }
public CodeTreeBuilder createBuilder() { CodeTreeBuilder builder = new CodeTreeBuilder(null); builder.setEnclosingElement(this); this.bodyTree = builder.getTree(); this.body = null; return builder; }
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; }
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(); }
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 createFastPathExecute(CodeTreeBuilder parent, final ExecutableTypeData forType, SpecializationData specialization, LocalContext currentValues) { CodeTreeBuilder builder = parent.create(); int ifCount = 0; if (specialization.isFallback()) { builder.startIf().startCall("guardFallback"); if (node.isFrameUsedByAnyGuard()) { if (currentValues.get(FRAME_VALUE) != null) { builder.string(FRAME_VALUE); } else { builder.nullLiteral(); builder.end(); builder.end(); builder.startBlock(); ifCount++; CodeTreeBuilder execute = builder.create(); builder.startTryBlock(); for (AssumptionExpression assumption : specialization.getAssumptionExpressions()) { LocalVariable assumptionVar = currentValues.get(assumptionName(assumption)); builder.startStatement().startCall("check").tree(assumptionVar.createReference()).end().end(); builder.end().startCatchBlock(getType(InvalidAssumptionException.class), "ae"); builder.startReturn(); List<String> assumptionIds = new ArrayList<>(); for (AssumptionExpression assumption : specialization.getAssumptionExpressions()) { assumptionIds.add(assumption.getId());
CodeTreeBuilder builder = new CodeTreeBuilder(null); Parameter parameter = cache.getParameter(); builder = new CodeTreeBuilder(null); String fieldName = createFieldName(specialization, cache.getParameter()) + "__"; String insertName = useSpecializationClass ? useInsertAccessor(specialization, !isNodeInterface) : "insert"; CodeTreeBuilder noCast = new CodeTreeBuilder(null); noCast.startCall(insertTarget, insertName); noCast.tree(value); noCast.end(); value = noCast.build(); } else { builder.declaration(cache.getExpression().getResolvedType(), fieldName, value); builder.startIf().string(fieldName).instanceOf(castType).end().startBlock(); builder.startStatement().startCall(insertTarget, insertName); builder.startGroup().cast(castType).string(fieldName).end(); builder.end().end(); builder.end(); value = CodeTreeBuilder.singleString(fieldName); builder.startStatement(); builder.tree(createCacheReference(frameState, specialization, cache.getParameter())).string(" = ").tree(value); builder.end(); triples.add(new IfTriple(builder.build(), null, null)); return triples;
CodeTreeBuilder builder = parent.create(); if (!useDuplicate) { builder.declaration("int", countName, CodeTreeBuilder.singleString("0")); builder.tree(loadSpecializationClass(frameState, specialization)); builder.declaration("boolean", duplicateFoundName, CodeTreeBuilder.singleString("false")); builder.startIf().tree(state.createContains(frameState, new Object[]{specialization})).end().startBlock(); builder.startWhile().string(specializationLocalName, " != null").end().startBlock(); int duplicationIfCount = IfTriple.materialize(builder, IfTriple.optimize(duplicationtriples), false); if (useDuplicate) { builder.startStatement().string(duplicateFoundName, " = true").end(); builder.statement("break"); builder.end(duplicationIfCount); builder.startStatement().string(specializationLocalName, " = ", specializationLocalName, ".next_").end(); } else { builder.statement(specializationLocalName + " = null"); builder.statement(countName + "++"); builder.end(); 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(); }
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 createFastPathExecuteChild(final CodeTreeBuilder parent, FrameState originalFrameState, FrameState frameState, final ExecutableTypeData currentType, SpecializationGroup group, NodeExecutionData execution) { CodeTreeBuilder builder = parent.create(); builder.declaration(sType, localName, CodeTreeBuilder.createBuilder().defaultValue(sType).build()); CodeTreeBuilder accessBuilder = builder.create(); accessBuilder.startParantheses(); accessBuilder.tree(state.createContainsOnly(frameState, originalSourceTypes.indexOf(sType), 1, new Object[]{typeGuard}, new Object[]{typeGuard})); accessBuilder.string(" && "); accessBuilder.tree(state.createIsNotAny(frameState, reachableSpecializationsArray)); accessBuilder.string(" ? "); if (ElementUtils.isPrimitive(sType)) { accessBuilder.string("(").type(generic).string(") "); accessBuilder.string(localName); accessBuilder.string(" : "); if (first && ElementUtils.isPrimitive(targetType)) { accessBuilder.string("(").type(generic).string(") "); accessBuilder.tree(access); accessBuilder.end(); access = accessBuilder.build(); first = false; builder.tree(createAssignExecuteChild(originalFrameState, frameState, builder, execution, currentType, var)); frameState.setValue(execution, var);
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(); }
builder.declaration(context.getType(Lock.class), "lock", "getLock()"); builder.declaration(context.getType(boolean.class), "hasLock", "true"); builder.statement("lock.lock()"); builder.tree(state.createLoad(frameState)); if (requiresExclude()) { builder.tree(exclude.createLoad(frameState)); builder.startTryBlock(); CodeTree execution = visitSpecializationGroup(builder, group, executeAndSpecializeType, frameState, null, NodeExecutionMode.SLOW_PATH); builder.tree(execution); builder.tree(createTransferToInterpreterAndInvalidate()); builder.tree(createThrowUnsupported(builder, originalFrameState)); builder.end().startFinallyBlock(); if (shouldReportPolymorphism(node, reachableSpecializations)) { generateCheckNewPolymorphismState(builder); builder.startIf().string("hasLock").end().startBlock(); builder.statement("lock.unlock()"); builder.end(); builder.end();
private Element createCreate(CodeTypeElement clazz) { String methodName = "create"; CodeExecutableElement method = new CodeExecutableElement(modifiers(PUBLIC, STATIC), clazz.asType(), methodName); method.addParameter(new CodeVariableElement(context.getType(Object.class), "value")); CodeTreeBuilder builder = method.createBuilder(); builder.declaration(clazz.asType(), "newCast", builder.create().startNew(clazz.asType()).end()); for (TypeMirror sourceType : sourceTypes) { String seenField = seenFieldName(sourceType); builder.startStatement(); builder.string("newCast.").string(seenField).string(" = ").tree(TypeSystemCodeGenerator.check(typeSystem, sourceType, "value")); builder.end(); } builder.startReturn().string("newCast").end(); return method; }
private CodeTree createThrowUnsupported(final CodeTreeBuilder parent, final FrameState frameState) { CodeTreeBuilder builder = parent.create(); builder.startThrow().startNew(context.getType(UnsupportedSpecializationException.class)); builder.string("this"); builder.startNewArray(new ArrayCodeTypeMirror(context.getType(Node.class)), null); List<CodeTree> values = new ArrayList<>(); for (NodeExecutionData execution : node.getChildExecutions()) { NodeChildData child = execution.getChild(); LocalVariable var = frameState.getValue(execution); if (child != null) { builder.string(accessNodeField(execution)); } else { builder.string("null"); } if (var != null) { values.add(var.createReference()); } } builder.end(); builder.trees(values.toArray(new CodeTree[0])); builder.end().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 createIsOneBitOf(FrameState frameState, Object[] elements) { CodeTree masked = createMaskedReference(frameState, elements); CodeTreeBuilder builder = CodeTreeBuilder.createBuilder(); // use the calculation of power of two // (state & (state - 1L)) == 0L builder.startParantheses().tree(masked).string(" & ").startParantheses().tree(masked).string(" - 1").end().end().string(" == 0"); builder.string(" /* ", label("is-single"), " */"); return builder.build(); }