001 /*
002 * Copyright 2010-2013 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.jet.lang.cfg;
018
019 import org.jetbrains.annotations.NotNull;
020 import org.jetbrains.annotations.Nullable;
021 import org.jetbrains.jet.lang.cfg.pseudocode.PseudoValue;
022 import org.jetbrains.jet.lang.cfg.pseudocode.Pseudocode;
023 import org.jetbrains.jet.lang.cfg.pseudocode.TypePredicate;
024 import org.jetbrains.jet.lang.cfg.pseudocode.instructions.eval.*;
025 import org.jetbrains.jet.lang.descriptors.ValueParameterDescriptor;
026 import org.jetbrains.jet.lang.psi.*;
027 import org.jetbrains.jet.lang.resolve.calls.model.ResolvedCall;
028 import org.jetbrains.jet.lang.resolve.constants.CompileTimeConstant;
029 import org.jetbrains.jet.lang.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 createFunctionLiteral(@NotNull JetFunctionLiteralExpression expression) {
059 return getDelegateBuilder().createFunctionLiteral(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 public void compilationError(@NotNull JetElement element, @NotNull String message) {
119 getDelegateBuilder().compilationError(element, message);
120 }
121
122 @Override
123 @NotNull
124 public Label createUnboundLabel() {
125 return getDelegateBuilder().createUnboundLabel();
126 }
127
128 @NotNull
129 @Override
130 public Label createUnboundLabel(@NotNull String name) {
131 return getDelegateBuilder().createUnboundLabel(name);
132 }
133
134 @Override
135 public void bindLabel(@NotNull Label label) {
136 getDelegateBuilder().bindLabel(label);
137 }
138
139 @Override
140 public void jump(@NotNull Label label, @NotNull JetElement element) {
141 getDelegateBuilder().jump(label, element);
142 }
143
144 @Override
145 public void jumpOnFalse(@NotNull Label label, @NotNull JetElement element, @Nullable PseudoValue conditionValue) {
146 getDelegateBuilder().jumpOnFalse(label, element, conditionValue);
147 }
148
149 @Override
150 public void jumpOnTrue(@NotNull Label label, @NotNull JetElement element, @Nullable PseudoValue conditionValue) {
151 getDelegateBuilder().jumpOnTrue(label, element, conditionValue);
152 }
153
154 @Override
155 public void nondeterministicJump(@NotNull Label label, @NotNull JetElement element, @Nullable PseudoValue inputValue) {
156 getDelegateBuilder().nondeterministicJump(label, element, inputValue);
157 }
158
159 @Override
160 public void nondeterministicJump(@NotNull List<Label> labels, @NotNull JetElement element) {
161 getDelegateBuilder().nondeterministicJump(labels, element);
162 }
163
164 @Override
165 public void jumpToError(@NotNull JetElement element) {
166 getDelegateBuilder().jumpToError(element);
167 }
168
169 @Override
170 public void throwException(@NotNull JetThrowExpression throwExpression, @NotNull PseudoValue thrownValue) {
171 getDelegateBuilder().throwException(throwExpression, thrownValue);
172 }
173
174 @Override
175 @NotNull
176 public Label getEntryPoint(@NotNull JetElement labelElement) {
177 return getDelegateBuilder().getEntryPoint(labelElement);
178 }
179
180 @NotNull
181 @Override
182 public Label getExitPoint(@NotNull JetElement labelElement) {
183 return getDelegateBuilder().getExitPoint(labelElement);
184 }
185
186 @NotNull
187 @Override
188 public Label getConditionEntryPoint(@NotNull JetElement labelElement) {
189 return getDelegateBuilder().getConditionEntryPoint(labelElement);
190 }
191
192 @NotNull
193 @Override
194 public LoopInfo enterLoop(@NotNull JetLoopExpression expression) {
195 return getDelegateBuilder().enterLoop(expression);
196 }
197
198 @Override
199 public void enterLoopBody(@NotNull JetLoopExpression expression) {
200 getDelegateBuilder().enterLoopBody(expression);
201 }
202
203 @Override
204 public void exitLoopBody(@NotNull JetLoopExpression expression) {
205 getDelegateBuilder().exitLoopBody(expression);
206 }
207
208 @Override
209 @Nullable
210 public JetLoopExpression getCurrentLoop() {
211 return getDelegateBuilder().getCurrentLoop();
212 }
213
214 @Override
215 public void enterTryFinally(@NotNull GenerationTrigger trigger) {
216 getDelegateBuilder().enterTryFinally(trigger);
217 }
218
219 @Override
220 public void exitTryFinally() {
221 getDelegateBuilder().exitTryFinally();
222 }
223
224 @Override
225 public void enterSubroutine(@NotNull JetElement subroutine) {
226 getDelegateBuilder().enterSubroutine(subroutine);
227 }
228
229 @NotNull
230 @Override
231 public Pseudocode exitSubroutine(@NotNull JetElement subroutine) {
232 return getDelegateBuilder().exitSubroutine(subroutine);
233 }
234
235 @NotNull
236 @Override
237 public JetElement getCurrentSubroutine() {
238 return getDelegateBuilder().getCurrentSubroutine();
239 }
240
241 @Override
242 @Nullable
243 public JetElement getReturnSubroutine() {
244 return getDelegateBuilder().getReturnSubroutine();
245 }
246
247 @Override
248 public void returnValue(@NotNull JetExpression returnExpression, @NotNull PseudoValue returnValue, @NotNull JetElement subroutine) {
249 getDelegateBuilder().returnValue(returnExpression, returnValue, subroutine);
250 }
251
252 @Override
253 public void returnNoValue(@NotNull JetReturnExpression returnExpression, @NotNull JetElement subroutine) {
254 getDelegateBuilder().returnNoValue(returnExpression, subroutine);
255 }
256
257 @Override
258 public void write(
259 @NotNull JetElement assignment,
260 @NotNull JetElement lValue,
261 @NotNull PseudoValue rValue,
262 @NotNull AccessTarget target,
263 @NotNull Map<PseudoValue, ReceiverValue> receiverValues) {
264 getDelegateBuilder().write(assignment, lValue, rValue, target, receiverValues);
265 }
266
267 @Override
268 public void declareParameter(@NotNull JetParameter parameter) {
269 getDelegateBuilder().declareParameter(parameter);
270 }
271
272 @Override
273 public void declareVariable(@NotNull JetVariableDeclaration property) {
274 getDelegateBuilder().declareVariable(property);
275 }
276
277 @Override
278 public void declareFunction(@NotNull JetElement subroutine, @NotNull Pseudocode pseudocode) {
279 getDelegateBuilder().declareFunction(subroutine, pseudocode);
280 }
281
282 @Override
283 public void repeatPseudocode(@NotNull Label startLabel, @NotNull Label finishLabel) {
284 getDelegateBuilder().repeatPseudocode(startLabel, finishLabel);
285 }
286
287 @Override
288 public void mark(@NotNull JetElement element) {
289 getDelegateBuilder().mark(element);
290 }
291
292 @Nullable
293 @Override
294 public PseudoValue getBoundValue(@Nullable JetElement element) {
295 return getDelegateBuilder().getBoundValue(element);
296 }
297
298 @Override
299 public void bindValue(@NotNull PseudoValue value, @NotNull JetElement element) {
300 getDelegateBuilder().bindValue(value, element);
301 }
302
303 @NotNull
304 @Override
305 public PseudoValue newValue(@Nullable JetElement element) {
306 return getDelegateBuilder().newValue(element);
307 }
308
309 @Override
310 public void enterLexicalScope(@NotNull JetElement element) {
311 getDelegateBuilder().enterLexicalScope(element);
312 }
313
314 @Override
315 public void exitLexicalScope(@NotNull JetElement element) {
316 getDelegateBuilder().exitLexicalScope(element);
317 }
318 }