ControlFlowBuilderAdapter: converted to Kotlin

This commit is contained in:
Mikhail Glukhikh
2016-01-26 18:18:45 +03:00
parent 5a405f3ddb
commit 6ba171297c
@@ -14,298 +14,218 @@
* limitations under the License. * limitations under the License.
*/ */
package org.jetbrains.kotlin.cfg; package org.jetbrains.kotlin.cfg
import org.jetbrains.annotations.NotNull; import org.jetbrains.kotlin.cfg.pseudocode.PseudoValue
import org.jetbrains.annotations.Nullable; import org.jetbrains.kotlin.cfg.pseudocode.Pseudocode
import org.jetbrains.kotlin.cfg.pseudocode.PseudoValue; import org.jetbrains.kotlin.cfg.pseudocode.instructions.eval.*
import org.jetbrains.kotlin.cfg.pseudocode.Pseudocode; import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor
import org.jetbrains.kotlin.cfg.pseudocode.instructions.eval.*; import org.jetbrains.kotlin.psi.*
import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor; import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall
import org.jetbrains.kotlin.psi.*; import org.jetbrains.kotlin.resolve.constants.CompileTimeConstant
import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall; import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue
import org.jetbrains.kotlin.resolve.constants.CompileTimeConstant;
import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue;
import java.util.List; abstract class ControlFlowBuilderAdapter : ControlFlowBuilder {
import java.util.Map;
public abstract class ControlFlowBuilderAdapter implements ControlFlowBuilder { protected abstract val delegateBuilder: ControlFlowBuilder
@NotNull override fun loadUnit(expression: KtExpression) {
protected abstract ControlFlowBuilder getDelegateBuilder(); delegateBuilder.loadUnit(expression)
@Override
public void loadUnit(@NotNull KtExpression expression) {
getDelegateBuilder().loadUnit(expression);
} }
@NotNull override fun loadConstant(expression: KtExpression, constant: CompileTimeConstant<*>?): InstructionWithValue {
@Override return delegateBuilder.loadConstant(expression, constant)
public InstructionWithValue loadConstant(@NotNull KtExpression expression, @Nullable CompileTimeConstant<?> constant) {
return getDelegateBuilder().loadConstant(expression, constant);
} }
@NotNull override fun createAnonymousObject(expression: KtObjectLiteralExpression): InstructionWithValue {
@Override return delegateBuilder.createAnonymousObject(expression)
public InstructionWithValue createAnonymousObject(@NotNull KtObjectLiteralExpression expression) {
return getDelegateBuilder().createAnonymousObject(expression);
} }
@NotNull override fun createLambda(expression: KtFunction): InstructionWithValue {
@Override return delegateBuilder.createLambda(expression)
public InstructionWithValue createLambda(@NotNull KtFunction expression) {
return getDelegateBuilder().createLambda(expression);
} }
@NotNull override fun loadStringTemplate(expression: KtStringTemplateExpression, inputValues: List<PseudoValue>): InstructionWithValue {
@Override return delegateBuilder.loadStringTemplate(expression, inputValues)
public InstructionWithValue loadStringTemplate(@NotNull KtStringTemplateExpression expression, @NotNull List<? extends PseudoValue> inputValues) {
return getDelegateBuilder().loadStringTemplate(expression, inputValues);
} }
@NotNull override fun magic(
@Override instructionElement: KtElement,
public MagicInstruction magic( valueElement: KtElement?,
@NotNull KtElement instructionElement, inputValues: List<PseudoValue>,
@Nullable KtElement valueElement, kind: MagicKind): MagicInstruction {
@NotNull List<? extends PseudoValue> inputValues, return delegateBuilder.magic(instructionElement, valueElement, inputValues, kind)
@NotNull MagicKind kind
) {
return getDelegateBuilder().magic(instructionElement, valueElement, inputValues, kind);
} }
@NotNull override fun merge(expression: KtExpression, inputValues: List<PseudoValue>): MergeInstruction {
@Override return delegateBuilder.merge(expression, inputValues)
public MergeInstruction merge(@NotNull KtExpression expression, @NotNull List<? extends PseudoValue> inputValues) {
return getDelegateBuilder().merge(expression, inputValues);
} }
@NotNull override fun readVariable(
@Override expression: KtExpression,
public ReadValueInstruction readVariable( resolvedCall: ResolvedCall<*>,
@NotNull KtExpression expression, receiverValues: Map<PseudoValue, ReceiverValue>): ReadValueInstruction {
@NotNull ResolvedCall<?> resolvedCall, return delegateBuilder.readVariable(expression, resolvedCall, receiverValues)
@NotNull Map<PseudoValue, ? extends ReceiverValue> receiverValues
) {
return getDelegateBuilder().readVariable(expression, resolvedCall, receiverValues);
} }
@NotNull override fun call(
@Override valueElement: KtElement,
public CallInstruction call( resolvedCall: ResolvedCall<*>,
@NotNull KtElement valueElement, receiverValues: Map<PseudoValue, ReceiverValue>,
@NotNull ResolvedCall<?> resolvedCall, arguments: Map<PseudoValue, ValueParameterDescriptor>): CallInstruction {
@NotNull Map<PseudoValue, ? extends ReceiverValue> receiverValues, return delegateBuilder.call(valueElement, resolvedCall, receiverValues, arguments)
@NotNull Map<PseudoValue, ? extends ValueParameterDescriptor> arguments
) {
return getDelegateBuilder().call(valueElement, resolvedCall, receiverValues, arguments);
} }
@NotNull override fun predefinedOperation(
@Override expression: KtExpression,
public OperationInstruction predefinedOperation( operation: ControlFlowBuilder.PredefinedOperation,
@NotNull KtExpression expression, inputValues: List<PseudoValue>): OperationInstruction {
@NotNull PredefinedOperation operation, return delegateBuilder.predefinedOperation(expression, operation, inputValues)
@NotNull List<? extends PseudoValue> inputValues
) {
return getDelegateBuilder().predefinedOperation(expression, operation, inputValues);
} }
@Override override fun createUnboundLabel(): Label {
@NotNull return delegateBuilder.createUnboundLabel()
public Label createUnboundLabel() {
return getDelegateBuilder().createUnboundLabel();
} }
@NotNull override fun createUnboundLabel(name: String): Label {
@Override return delegateBuilder.createUnboundLabel(name)
public Label createUnboundLabel(@NotNull String name) {
return getDelegateBuilder().createUnboundLabel(name);
} }
@Override override fun bindLabel(label: Label) {
public void bindLabel(@NotNull Label label) { delegateBuilder.bindLabel(label)
getDelegateBuilder().bindLabel(label);
} }
@Override override fun jump(label: Label, element: KtElement) {
public void jump(@NotNull Label label, @NotNull KtElement element) { delegateBuilder.jump(label, element)
getDelegateBuilder().jump(label, element);
} }
@Override override fun jumpOnFalse(label: Label, element: KtElement, conditionValue: PseudoValue?) {
public void jumpOnFalse(@NotNull Label label, @NotNull KtElement element, @Nullable PseudoValue conditionValue) { delegateBuilder.jumpOnFalse(label, element, conditionValue)
getDelegateBuilder().jumpOnFalse(label, element, conditionValue);
} }
@Override override fun jumpOnTrue(label: Label, element: KtElement, conditionValue: PseudoValue?) {
public void jumpOnTrue(@NotNull Label label, @NotNull KtElement element, @Nullable PseudoValue conditionValue) { delegateBuilder.jumpOnTrue(label, element, conditionValue)
getDelegateBuilder().jumpOnTrue(label, element, conditionValue);
} }
@Override override fun nondeterministicJump(label: Label, element: KtElement, inputValue: PseudoValue?) {
public void nondeterministicJump(@NotNull Label label, @NotNull KtElement element, @Nullable PseudoValue inputValue) { delegateBuilder.nondeterministicJump(label, element, inputValue)
getDelegateBuilder().nondeterministicJump(label, element, inputValue);
} }
@Override override fun nondeterministicJump(label: List<Label>, element: KtElement) {
public void nondeterministicJump(@NotNull List<? extends Label> labels, @NotNull KtElement element) { delegateBuilder.nondeterministicJump(label, element)
getDelegateBuilder().nondeterministicJump(labels, element);
} }
@Override override fun jumpToError(element: KtElement) {
public void jumpToError(@NotNull KtElement element) { delegateBuilder.jumpToError(element)
getDelegateBuilder().jumpToError(element);
} }
@Override override fun throwException(throwExpression: KtThrowExpression, thrownValue: PseudoValue) {
public void throwException(@NotNull KtThrowExpression throwExpression, @NotNull PseudoValue thrownValue) { delegateBuilder.throwException(throwExpression, thrownValue)
getDelegateBuilder().throwException(throwExpression, thrownValue);
} }
@Override override fun getEntryPoint(labelElement: KtElement): Label {
@NotNull return delegateBuilder.getEntryPoint(labelElement)
public Label getEntryPoint(@NotNull KtElement labelElement) {
return getDelegateBuilder().getEntryPoint(labelElement);
} }
@NotNull override fun getExitPoint(labelElement: KtElement): Label {
@Override return delegateBuilder.getExitPoint(labelElement)
public Label getExitPoint(@NotNull KtElement labelElement) {
return getDelegateBuilder().getExitPoint(labelElement);
} }
@NotNull override fun getConditionEntryPoint(labelElement: KtElement): Label {
@Override return delegateBuilder.getConditionEntryPoint(labelElement)
public Label getConditionEntryPoint(@NotNull KtElement labelElement) {
return getDelegateBuilder().getConditionEntryPoint(labelElement);
} }
@NotNull override fun enterLoop(expression: KtLoopExpression): LoopInfo {
@Override return delegateBuilder.enterLoop(expression)
public LoopInfo enterLoop(@NotNull KtLoopExpression expression) {
return getDelegateBuilder().enterLoop(expression);
} }
@Override override fun enterLoopBody(expression: KtLoopExpression) {
public void enterLoopBody(@NotNull KtLoopExpression expression) { delegateBuilder.enterLoopBody(expression)
getDelegateBuilder().enterLoopBody(expression);
} }
@Override override fun exitLoopBody(expression: KtLoopExpression) {
public void exitLoopBody(@NotNull KtLoopExpression expression) { delegateBuilder.exitLoopBody(expression)
getDelegateBuilder().exitLoopBody(expression);
} }
@Override override val currentLoop: KtLoopExpression?
@Nullable get() = delegateBuilder.currentLoop
public KtLoopExpression getCurrentLoop() {
return getDelegateBuilder().getCurrentLoop(); override fun enterTryFinally(trigger: GenerationTrigger) {
delegateBuilder.enterTryFinally(trigger)
} }
@Override override fun exitTryFinally() {
public void enterTryFinally(@NotNull GenerationTrigger trigger) { delegateBuilder.exitTryFinally()
getDelegateBuilder().enterTryFinally(trigger);
} }
@Override override fun enterSubroutine(subroutine: KtElement) {
public void exitTryFinally() { delegateBuilder.enterSubroutine(subroutine)
getDelegateBuilder().exitTryFinally();
} }
@Override override fun exitSubroutine(subroutine: KtElement): Pseudocode {
public void enterSubroutine(@NotNull KtElement subroutine) { return delegateBuilder.exitSubroutine(subroutine)
getDelegateBuilder().enterSubroutine(subroutine);
} }
@NotNull override val currentSubroutine: KtElement
@Override get() = delegateBuilder.currentSubroutine
public Pseudocode exitSubroutine(@NotNull KtElement subroutine) {
return getDelegateBuilder().exitSubroutine(subroutine); override val returnSubroutine: KtElement?
get() = delegateBuilder.returnSubroutine
override fun returnValue(returnExpression: KtExpression, returnValue: PseudoValue, subroutine: KtElement) {
delegateBuilder.returnValue(returnExpression, returnValue, subroutine)
} }
@NotNull override fun returnNoValue(returnExpression: KtReturnExpression, subroutine: KtElement) {
@Override delegateBuilder.returnNoValue(returnExpression, subroutine)
public KtElement getCurrentSubroutine() {
return getDelegateBuilder().getCurrentSubroutine();
} }
@Override override fun write(
@Nullable assignment: KtElement,
public KtElement getReturnSubroutine() { lValue: KtElement,
return getDelegateBuilder().getReturnSubroutine(); rValue: PseudoValue,
target: AccessTarget,
receiverValues: Map<PseudoValue, ReceiverValue>) {
delegateBuilder.write(assignment, lValue, rValue, target, receiverValues)
} }
@Override override fun declareParameter(parameter: KtParameter) {
public void returnValue(@NotNull KtExpression returnExpression, @NotNull PseudoValue returnValue, @NotNull KtElement subroutine) { delegateBuilder.declareParameter(parameter)
getDelegateBuilder().returnValue(returnExpression, returnValue, subroutine);
} }
@Override override fun declareVariable(property: KtVariableDeclaration) {
public void returnNoValue(@NotNull KtReturnExpression returnExpression, @NotNull KtElement subroutine) { delegateBuilder.declareVariable(property)
getDelegateBuilder().returnNoValue(returnExpression, subroutine);
} }
@Override override fun declareFunction(subroutine: KtElement, pseudocode: Pseudocode) {
public void write( delegateBuilder.declareFunction(subroutine, pseudocode)
@NotNull KtElement assignment,
@NotNull KtElement lValue,
@NotNull PseudoValue rValue,
@NotNull AccessTarget target,
@NotNull Map<PseudoValue, ? extends ReceiverValue> receiverValues) {
getDelegateBuilder().write(assignment, lValue, rValue, target, receiverValues);
} }
@Override override fun repeatPseudocode(startLabel: Label, finishLabel: Label) {
public void declareParameter(@NotNull KtParameter parameter) { delegateBuilder.repeatPseudocode(startLabel, finishLabel)
getDelegateBuilder().declareParameter(parameter);
} }
@Override override fun mark(element: KtElement) {
public void declareVariable(@NotNull KtVariableDeclaration property) { delegateBuilder.mark(element)
getDelegateBuilder().declareVariable(property);
} }
@Override override fun getBoundValue(element: KtElement?): PseudoValue? {
public void declareFunction(@NotNull KtElement subroutine, @NotNull Pseudocode pseudocode) { return delegateBuilder.getBoundValue(element)
getDelegateBuilder().declareFunction(subroutine, pseudocode);
} }
@Override override fun bindValue(value: PseudoValue, element: KtElement) {
public void repeatPseudocode(@NotNull Label startLabel, @NotNull Label finishLabel) { delegateBuilder.bindValue(value, element)
getDelegateBuilder().repeatPseudocode(startLabel, finishLabel);
} }
@Override override fun newValue(element: KtElement?): PseudoValue {
public void mark(@NotNull KtElement element) { return delegateBuilder.newValue(element)
getDelegateBuilder().mark(element);
} }
@Nullable override fun enterLexicalScope(element: KtElement) {
@Override delegateBuilder.enterLexicalScope(element)
public PseudoValue getBoundValue(@Nullable KtElement element) {
return getDelegateBuilder().getBoundValue(element);
} }
@Override override fun exitLexicalScope(element: KtElement) {
public void bindValue(@NotNull PseudoValue value, @NotNull KtElement element) { delegateBuilder.exitLexicalScope(element)
getDelegateBuilder().bindValue(value, element);
}
@NotNull
@Override
public PseudoValue newValue(@Nullable KtElement element) {
return getDelegateBuilder().newValue(element);
}
@Override
public void enterLexicalScope(@NotNull KtElement element) {
getDelegateBuilder().enterLexicalScope(element);
}
@Override
public void exitLexicalScope(@NotNull KtElement element) {
getDelegateBuilder().exitLexicalScope(element);
} }
} }