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