public CodeTreeBuilder returnStatement() { return statement("return"); }
public CodeTreeBuilder returnStatement() { return statement("return"); }
builder.statement("this." + createSpecializationFieldName(excludes) + " = null");
private Element createCountCaches() { TypeMirror returnType = getType(int.class); CodeExecutableElement executable = new CodeExecutableElement(modifiers(PRIVATE), returnType, COUNT_CACHES); CodeTreeBuilder builder = executable.createBuilder(); final String cacheCount = "cache" + COUNT_SUFIX; builder.declaration(context.getType(int.class), cacheCount, "0"); for (SpecializationData specialization : reachableSpecializations) { if (useSpecializationClass(specialization) && specialization.getMaximumNumberOfInstances() > 1) { String typeName = createSpecializationTypeName(specialization); String fieldName = createSpecializationFieldName(specialization); String localName = createSpecializationLocalName(specialization); builder.declaration(typeName, localName, "this." + fieldName); builder.startWhile().string(localName, " != null"); builder.end(); builder.startBlock().statement(cacheCount + "++").statement(localName + "= " + localName + ".next_"); builder.end(); } } builder.startReturn().statement(cacheCount); return executable; }
builder = builder.create(); if (isVoid(forType.getReturnType())) { builder.statement(call); builder.returnStatement(); } else {
builder.statement("lock.lock()"); builder.startTryBlock(); String fieldName = createSpecializationFieldName(specialization); builder.statement("this." + fieldName + " = null"); builder.startIf().string("cur == ").string(specializationLocalName).end().startBlock(); builder.startIf().string("prev == null").end().startBlock(); builder.statement("this." + fieldName + " = cur.next_"); if (specializedIsNode) { builder.statement("this.adoptChildren()"); builder.statement("prev.next_ = cur.next_"); if (specializedIsNode) { builder.statement("prev.adoptChildren()"); builder.statement("break"); builder.statement("prev = cur"); builder.statement("cur = cur.next_"); builder.statement("lock.unlock()"); builder.end(); removeThisMethods.put(specialization, method);
private CodeTree createExecute(CodeTreeBuilder parent, FrameState frameState, final ExecutableTypeData forType, SpecializationData specialization, NodeExecutionMode mode) { CodeTreeBuilder builder = parent.create(); if (mode.isSlowPath()) { builder.statement("lock.unlock()"); builder.statement("hasLock = false"); } if (specialization.getMethod() == null) { builder.tree(createThrowUnsupported(builder, frameState)); } else { if (isVoid(specialization.getMethod().getReturnType())) { builder.statement(callTemplateMethod(null, specialization, frameState)); if (isVoid(forType.getReturnType())) { builder.returnStatement(); } else { builder.startReturn().defaultValue(forType.getReturnType()).end(); } } else { builder.startReturn(); builder.tree(expectOrCast(specialization.getReturnType().getType(), forType, callTemplateMethod(null, specialization, frameState))); builder.end(); } } return createCatchRewriteException(builder, specialization, forType, frameState, builder.build(), mode); }
private CodeExecutableElement createExecuteChildMethod(NodeExecutionData execution, TypeMirror targetType) { if (!usedExecuteChildMethods.contains(execution)) { return null; } LocalContext locals = LocalContext.load(this, createSpecializationNodeSignature(0), Integer.MAX_VALUE); CodeExecutableElement method = locals.createMethod(modifiers(PROTECTED, FINAL), targetType, executeChildMethodName(execution, targetType), Integer.MAX_VALUE, FRAME_VALUE); if (hasChildUnexpectedResult(execution, targetType)) { method.getThrownTypes().add(getType(UnexpectedResultException.class)); } CodeVariableElement implicitProfile = createImplicitProfileParameter(execution, targetType); if (implicitProfile != null) { method.addParameter(implicitProfile); } for (int i = 0; i < execution.getChild().getExecuteWith().size(); i++) { NodeExecutionData executeWith = node.getChildExecutions().get(i); LocalVariable var = locals.createValue(executeWith, genericType); method.addParameter(var.createParameter()); locals.setValue(executeWith, var); } CodeTreeBuilder builder = method.createBuilder(); CodeTree executeChild = createExecuteChild(execution, locals.createValue(execution, targetType), locals, true); if (executeChild.isSingleLine()) { builder.statement(executeChild); } else { builder.tree(executeChild); } return method; }
builder.statement(callDelegate.build()); } else { builder.startStatement().string(returnName).string(" = ").tree(callDelegate.build()).end(); builder.statement("break"); if (wrappedExecute.getThrownTypes().contains(context.getType(UnexpectedResultException.class))) { builder.end().startCatchBlock(context.getType(UnexpectedResultException.class), "e"); builder.startIf().string("result == ").string(CONSTANT_REENTER).end(); builder.startBlock(); builder.statement("continue"); builder.end().startElseIf(); if (returnVoid) { builder.string("result != null").end(); builder.startBlock(); builder.statement("break"); } else { boolean objectReturnType = "java.lang.Object".equals(ElementUtils.getQualifiedName(returnTypeMirror)) && returnTypeMirror.getKind() != TypeKind.ARRAY; builder.statement("break"); } else { // can throw UnexpectedResultException builder.string("result").instanceOf(boxed(returnTypeMirror, context.getEnvironment().getTypeUtils())).end(); builder.string("(").string(ElementUtils.getSimpleName(returnTypeMirror)).string(") "); builder.string("result").end(); builder.statement("break"); builder.end(); builder.startElseIf().string("result != null").end();
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 createCallExecuteAndSpecialize(ExecutableTypeData forType, FrameState frameState) { TypeMirror returnType = node.getPolymorphicSpecialization().getReturnType().getType(); String frame = null; if (needsFrameToExecute(reachableSpecializations)) { frame = FRAME_VALUE; } CodeTreeBuilder builder = CodeTreeBuilder.createBuilder(); builder.startCall("executeAndSpecialize"); frameState.addReferencesTo(builder, frame); builder.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(); }
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.statement("lock.unlock()"); builder.end(); builder.end();
builder.end(); builder.startBlock(); builder.statement("removeSame(\"Contained by " + containedSpecialization.createReferenceName() + "\")"); builder.end();
builder.statement("super(index)"); constructor.addParameter(new CodeVariableElement(getType(int.class), "index")); } else { builder.startStatement().startSuperCall().string(constantIndex).end().end(); builder.statement("this.root = root"); } else { int index = resolveSpecializationIndex(specialization);
builder.statement("return s"); builder.end(); } else {