001 /*
002 * Copyright 2010-2015 JetBrains s.r.o.
003 *
004 * Licensed under the Apache License, Version 2.0 (the "License");
005 * you may not use this file except in compliance with the License.
006 * You may obtain a copy of the License at
007 *
008 * http://www.apache.org/licenses/LICENSE-2.0
009 *
010 * Unless required by applicable law or agreed to in writing, software
011 * distributed under the License is distributed on an "AS IS" BASIS,
012 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
013 * See the License for the specific language governing permissions and
014 * limitations under the License.
015 */
016
017 package org.jetbrains.kotlin.cfg;
018
019 import org.jetbrains.annotations.NotNull;
020 import org.jetbrains.annotations.Nullable;
021 import org.jetbrains.kotlin.cfg.pseudocode.PseudoValue;
022 import org.jetbrains.kotlin.cfg.pseudocode.Pseudocode;
023 import org.jetbrains.kotlin.cfg.pseudocode.instructions.eval.*;
024 import org.jetbrains.kotlin.descriptors.ValueParameterDescriptor;
025 import org.jetbrains.kotlin.psi.*;
026 import org.jetbrains.kotlin.resolve.calls.model.ResolvedCall;
027 import org.jetbrains.kotlin.resolve.constants.CompileTimeConstant;
028 import org.jetbrains.kotlin.resolve.scopes.receivers.ReceiverValue;
029
030 import java.util.List;
031 import java.util.Map;
032
033 public abstract class JetControlFlowBuilderAdapter implements JetControlFlowBuilder {
034
035 @NotNull
036 protected abstract JetControlFlowBuilder getDelegateBuilder();
037
038 @Override
039 public void loadUnit(@NotNull JetExpression expression) {
040 getDelegateBuilder().loadUnit(expression);
041 }
042
043 @NotNull
044 @Override
045 public InstructionWithValue loadConstant(@NotNull JetExpression expression, @Nullable CompileTimeConstant<?> constant) {
046 return getDelegateBuilder().loadConstant(expression, constant);
047 }
048
049 @NotNull
050 @Override
051 public InstructionWithValue createAnonymousObject(@NotNull JetObjectLiteralExpression expression) {
052 return getDelegateBuilder().createAnonymousObject(expression);
053 }
054
055 @NotNull
056 @Override
057 public InstructionWithValue createLambda(@NotNull JetFunction expression) {
058 return getDelegateBuilder().createLambda(expression);
059 }
060
061 @NotNull
062 @Override
063 public InstructionWithValue loadStringTemplate(@NotNull JetStringTemplateExpression expression, @NotNull List<PseudoValue> inputValues) {
064 return getDelegateBuilder().loadStringTemplate(expression, inputValues);
065 }
066
067 @NotNull
068 @Override
069 public MagicInstruction magic(
070 @NotNull JetElement instructionElement,
071 @Nullable JetElement valueElement,
072 @NotNull List<PseudoValue> inputValues,
073 @NotNull MagicKind kind
074 ) {
075 return getDelegateBuilder().magic(instructionElement, valueElement, inputValues, kind);
076 }
077
078 @NotNull
079 @Override
080 public MergeInstruction merge(@NotNull JetExpression expression, @NotNull List<PseudoValue> inputValues) {
081 return getDelegateBuilder().merge(expression, inputValues);
082 }
083
084 @NotNull
085 @Override
086 public ReadValueInstruction readVariable(
087 @NotNull JetExpression expression,
088 @NotNull ResolvedCall<?> resolvedCall,
089 @NotNull Map<PseudoValue, ReceiverValue> receiverValues
090 ) {
091 return getDelegateBuilder().readVariable(expression, resolvedCall, receiverValues);
092 }
093
094 @NotNull
095 @Override
096 public CallInstruction call(
097 @NotNull JetElement valueElement,
098 @NotNull ResolvedCall<?> resolvedCall,
099 @NotNull Map<PseudoValue, ReceiverValue> receiverValues,
100 @NotNull Map<PseudoValue, ValueParameterDescriptor> arguments
101 ) {
102 return getDelegateBuilder().call(valueElement, resolvedCall, receiverValues, arguments);
103 }
104
105 @NotNull
106 @Override
107 public OperationInstruction predefinedOperation(
108 @NotNull JetExpression expression,
109 @NotNull PredefinedOperation operation,
110 @NotNull List<PseudoValue> inputValues
111 ) {
112 return getDelegateBuilder().predefinedOperation(expression, operation, inputValues);
113 }
114
115 @Override
116 @NotNull
117 public Label createUnboundLabel() {
118 return getDelegateBuilder().createUnboundLabel();
119 }
120
121 @NotNull
122 @Override
123 public Label createUnboundLabel(@NotNull String name) {
124 return getDelegateBuilder().createUnboundLabel(name);
125 }
126
127 @Override
128 public void bindLabel(@NotNull Label label) {
129 getDelegateBuilder().bindLabel(label);
130 }
131
132 @Override
133 public void jump(@NotNull Label label, @NotNull JetElement element) {
134 getDelegateBuilder().jump(label, element);
135 }
136
137 @Override
138 public void jumpOnFalse(@NotNull Label label, @NotNull JetElement element, @Nullable PseudoValue conditionValue) {
139 getDelegateBuilder().jumpOnFalse(label, element, conditionValue);
140 }
141
142 @Override
143 public void jumpOnTrue(@NotNull Label label, @NotNull JetElement element, @Nullable PseudoValue conditionValue) {
144 getDelegateBuilder().jumpOnTrue(label, element, conditionValue);
145 }
146
147 @Override
148 public void nondeterministicJump(@NotNull Label label, @NotNull JetElement element, @Nullable PseudoValue inputValue) {
149 getDelegateBuilder().nondeterministicJump(label, element, inputValue);
150 }
151
152 @Override
153 public void nondeterministicJump(@NotNull List<Label> labels, @NotNull JetElement element) {
154 getDelegateBuilder().nondeterministicJump(labels, element);
155 }
156
157 @Override
158 public void jumpToError(@NotNull JetElement element) {
159 getDelegateBuilder().jumpToError(element);
160 }
161
162 @Override
163 public void throwException(@NotNull JetThrowExpression throwExpression, @NotNull PseudoValue thrownValue) {
164 getDelegateBuilder().throwException(throwExpression, thrownValue);
165 }
166
167 @Override
168 @NotNull
169 public Label getEntryPoint(@NotNull JetElement labelElement) {
170 return getDelegateBuilder().getEntryPoint(labelElement);
171 }
172
173 @NotNull
174 @Override
175 public Label getExitPoint(@NotNull JetElement labelElement) {
176 return getDelegateBuilder().getExitPoint(labelElement);
177 }
178
179 @NotNull
180 @Override
181 public Label getConditionEntryPoint(@NotNull JetElement labelElement) {
182 return getDelegateBuilder().getConditionEntryPoint(labelElement);
183 }
184
185 @NotNull
186 @Override
187 public LoopInfo enterLoop(@NotNull JetLoopExpression expression) {
188 return getDelegateBuilder().enterLoop(expression);
189 }
190
191 @Override
192 public void enterLoopBody(@NotNull JetLoopExpression expression) {
193 getDelegateBuilder().enterLoopBody(expression);
194 }
195
196 @Override
197 public void exitLoopBody(@NotNull JetLoopExpression expression) {
198 getDelegateBuilder().exitLoopBody(expression);
199 }
200
201 @Override
202 @Nullable
203 public JetLoopExpression getCurrentLoop() {
204 return getDelegateBuilder().getCurrentLoop();
205 }
206
207 @Override
208 public void enterTryFinally(@NotNull GenerationTrigger trigger) {
209 getDelegateBuilder().enterTryFinally(trigger);
210 }
211
212 @Override
213 public void exitTryFinally() {
214 getDelegateBuilder().exitTryFinally();
215 }
216
217 @Override
218 public void enterSubroutine(@NotNull JetElement subroutine) {
219 getDelegateBuilder().enterSubroutine(subroutine);
220 }
221
222 @NotNull
223 @Override
224 public Pseudocode exitSubroutine(@NotNull JetElement subroutine) {
225 return getDelegateBuilder().exitSubroutine(subroutine);
226 }
227
228 @NotNull
229 @Override
230 public JetElement getCurrentSubroutine() {
231 return getDelegateBuilder().getCurrentSubroutine();
232 }
233
234 @Override
235 @Nullable
236 public JetElement getReturnSubroutine() {
237 return getDelegateBuilder().getReturnSubroutine();
238 }
239
240 @Override
241 public void returnValue(@NotNull JetExpression returnExpression, @NotNull PseudoValue returnValue, @NotNull JetElement subroutine) {
242 getDelegateBuilder().returnValue(returnExpression, returnValue, subroutine);
243 }
244
245 @Override
246 public void returnNoValue(@NotNull JetReturnExpression returnExpression, @NotNull JetElement subroutine) {
247 getDelegateBuilder().returnNoValue(returnExpression, subroutine);
248 }
249
250 @Override
251 public void write(
252 @NotNull JetElement assignment,
253 @NotNull JetElement lValue,
254 @NotNull PseudoValue rValue,
255 @NotNull AccessTarget target,
256 @NotNull Map<PseudoValue, ReceiverValue> receiverValues) {
257 getDelegateBuilder().write(assignment, lValue, rValue, target, receiverValues);
258 }
259
260 @Override
261 public void declareParameter(@NotNull JetParameter parameter) {
262 getDelegateBuilder().declareParameter(parameter);
263 }
264
265 @Override
266 public void declareVariable(@NotNull JetVariableDeclaration property) {
267 getDelegateBuilder().declareVariable(property);
268 }
269
270 @Override
271 public void declareFunction(@NotNull JetElement subroutine, @NotNull Pseudocode pseudocode) {
272 getDelegateBuilder().declareFunction(subroutine, pseudocode);
273 }
274
275 @Override
276 public void repeatPseudocode(@NotNull Label startLabel, @NotNull Label finishLabel) {
277 getDelegateBuilder().repeatPseudocode(startLabel, finishLabel);
278 }
279
280 @Override
281 public void mark(@NotNull JetElement element) {
282 getDelegateBuilder().mark(element);
283 }
284
285 @Nullable
286 @Override
287 public PseudoValue getBoundValue(@Nullable JetElement element) {
288 return getDelegateBuilder().getBoundValue(element);
289 }
290
291 @Override
292 public void bindValue(@NotNull PseudoValue value, @NotNull JetElement element) {
293 getDelegateBuilder().bindValue(value, element);
294 }
295
296 @NotNull
297 @Override
298 public PseudoValue newValue(@Nullable JetElement element) {
299 return getDelegateBuilder().newValue(element);
300 }
301
302 @Override
303 public void enterLexicalScope(@NotNull JetElement element) {
304 getDelegateBuilder().enterLexicalScope(element);
305 }
306
307 @Override
308 public void exitLexicalScope(@NotNull JetElement element) {
309 getDelegateBuilder().exitLexicalScope(element);
310 }
311 }