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 @Override
187 public LoopInfo enterLoop(@NotNull JetExpression expression, @Nullable Label loopExitPoint, Label conditionEntryPoint) {
188 return getDelegateBuilder().enterLoop(expression, loopExitPoint, conditionEntryPoint);
189 }
190
191 @Override
192 public void exitLoop(@NotNull JetExpression expression) {
193 getDelegateBuilder().exitLoop(expression);
194 }
195
196 @Override
197 @Nullable
198 public JetElement getCurrentLoop() {
199 return getDelegateBuilder().getCurrentLoop();
200 }
201
202 @Override
203 public void enterTryFinally(@NotNull GenerationTrigger trigger) {
204 getDelegateBuilder().enterTryFinally(trigger);
205 }
206
207 @Override
208 public void exitTryFinally() {
209 getDelegateBuilder().exitTryFinally();
210 }
211
212 @Override
213 public void enterSubroutine(@NotNull JetElement subroutine) {
214 getDelegateBuilder().enterSubroutine(subroutine);
215 }
216
217 @NotNull
218 @Override
219 public Pseudocode exitSubroutine(@NotNull JetElement subroutine) {
220 return getDelegateBuilder().exitSubroutine(subroutine);
221 }
222
223 @NotNull
224 @Override
225 public JetElement getCurrentSubroutine() {
226 return getDelegateBuilder().getCurrentSubroutine();
227 }
228
229 @Override
230 @Nullable
231 public JetElement getReturnSubroutine() {
232 return getDelegateBuilder().getReturnSubroutine();
233 }
234
235 @Override
236 public void returnValue(@NotNull JetExpression returnExpression, @NotNull PseudoValue returnValue, @NotNull JetElement subroutine) {
237 getDelegateBuilder().returnValue(returnExpression, returnValue, subroutine);
238 }
239
240 @Override
241 public void returnNoValue(@NotNull JetReturnExpression returnExpression, @NotNull JetElement subroutine) {
242 getDelegateBuilder().returnNoValue(returnExpression, subroutine);
243 }
244
245 @Override
246 public void write(
247 @NotNull JetElement assignment,
248 @NotNull JetElement lValue,
249 @NotNull PseudoValue rValue,
250 @NotNull AccessTarget target,
251 @NotNull Map<PseudoValue, ReceiverValue> receiverValues) {
252 getDelegateBuilder().write(assignment, lValue, rValue, target, receiverValues);
253 }
254
255 @Override
256 public void declareParameter(@NotNull JetParameter parameter) {
257 getDelegateBuilder().declareParameter(parameter);
258 }
259
260 @Override
261 public void declareVariable(@NotNull JetVariableDeclaration property) {
262 getDelegateBuilder().declareVariable(property);
263 }
264
265 @Override
266 public void declareFunction(@NotNull JetElement subroutine, @NotNull Pseudocode pseudocode) {
267 getDelegateBuilder().declareFunction(subroutine, pseudocode);
268 }
269
270 @Override
271 public void repeatPseudocode(@NotNull Label startLabel, @NotNull Label finishLabel) {
272 getDelegateBuilder().repeatPseudocode(startLabel, finishLabel);
273 }
274
275 @Override
276 public void mark(@NotNull JetElement element) {
277 getDelegateBuilder().mark(element);
278 }
279
280 @Nullable
281 @Override
282 public PseudoValue getBoundValue(@Nullable JetElement element) {
283 return getDelegateBuilder().getBoundValue(element);
284 }
285
286 @Override
287 public void bindValue(@NotNull PseudoValue value, @NotNull JetElement element) {
288 getDelegateBuilder().bindValue(value, element);
289 }
290
291 @NotNull
292 @Override
293 public PseudoValue newValue(@Nullable JetElement element) {
294 return getDelegateBuilder().newValue(element);
295 }
296
297 @Override
298 public void enterLexicalScope(@NotNull JetElement element) {
299 getDelegateBuilder().enterLexicalScope(element);
300 }
301
302 @Override
303 public void exitLexicalScope(@NotNull JetElement element) {
304 getDelegateBuilder().exitLexicalScope(element);
305 }
306 }