]> git.uio.no Git - ifi-stolz-refaktor.git/blame - case-study/jdt-before/core refactoring/org/eclipse/jdt/internal/corext/refactoring/typeconstraints/ConstraintCreator.java
git://git.uio.no / ifi-stolz-refaktor.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Case Study: adding data and statistics
[ifi-stolz-refaktor.git] / case-study / jdt-before / core refactoring / org / eclipse / jdt / internal / corext / refactoring / typeconstraints / ConstraintCreator.java
CommitLineData
1b2798f6
EK		 1/*******************************************************************************
2 * Copyright (c) 2000, 2010 IBM Corporation and others.
3 * All rights reserved. This program and the accompanying materials
4 * are made available under the terms of the Eclipse Public License v1.0
5 * which accompanies this distribution, and is available at
6 * http://www.eclipse.org/legal/epl-v10.html
7 *
8 * Contributors:
9 * IBM Corporation - initial API and implementation
10 *******************************************************************************/
11package org.eclipse.jdt.internal.corext.refactoring.typeconstraints;
12
13import org.eclipse.jdt.core.dom.AnonymousClassDeclaration;
14import org.eclipse.jdt.core.dom.ArrayAccess;
15import org.eclipse.jdt.core.dom.ArrayCreation;
16import org.eclipse.jdt.core.dom.ArrayInitializer;
17import org.eclipse.jdt.core.dom.ArrayType;
18import org.eclipse.jdt.core.dom.AssertStatement;
19import org.eclipse.jdt.core.dom.Assignment;
20import org.eclipse.jdt.core.dom.Block;
21import org.eclipse.jdt.core.dom.BooleanLiteral;
22import org.eclipse.jdt.core.dom.BreakStatement;
23import org.eclipse.jdt.core.dom.CastExpression;
24import org.eclipse.jdt.core.dom.CatchClause;
25import org.eclipse.jdt.core.dom.CharacterLiteral;
26import org.eclipse.jdt.core.dom.ClassInstanceCreation;
27import org.eclipse.jdt.core.dom.CompilationUnit;
28import org.eclipse.jdt.core.dom.ConditionalExpression;
29import org.eclipse.jdt.core.dom.ConstructorInvocation;
30import org.eclipse.jdt.core.dom.ContinueStatement;
31import org.eclipse.jdt.core.dom.DoStatement;
32import org.eclipse.jdt.core.dom.EmptyStatement;
33import org.eclipse.jdt.core.dom.ExpressionStatement;
34import org.eclipse.jdt.core.dom.FieldAccess;
35import org.eclipse.jdt.core.dom.FieldDeclaration;
36import org.eclipse.jdt.core.dom.ForStatement;
37import org.eclipse.jdt.core.dom.IfStatement;
38import org.eclipse.jdt.core.dom.ImportDeclaration;
39import org.eclipse.jdt.core.dom.InfixExpression;
40import org.eclipse.jdt.core.dom.Initializer;
41import org.eclipse.jdt.core.dom.InstanceofExpression;
42import org.eclipse.jdt.core.dom.Javadoc;
43import org.eclipse.jdt.core.dom.LabeledStatement;
44import org.eclipse.jdt.core.dom.MethodDeclaration;
45import org.eclipse.jdt.core.dom.MethodInvocation;
46import org.eclipse.jdt.core.dom.NullLiteral;
47import org.eclipse.jdt.core.dom.NumberLiteral;
48import org.eclipse.jdt.core.dom.PackageDeclaration;
49import org.eclipse.jdt.core.dom.ParenthesizedExpression;
50import org.eclipse.jdt.core.dom.PostfixExpression;
51import org.eclipse.jdt.core.dom.PrefixExpression;
52import org.eclipse.jdt.core.dom.PrimitiveType;
53import org.eclipse.jdt.core.dom.QualifiedName;
54import org.eclipse.jdt.core.dom.ReturnStatement;
55import org.eclipse.jdt.core.dom.SimpleName;
56import org.eclipse.jdt.core.dom.SimpleType;
57import org.eclipse.jdt.core.dom.SingleVariableDeclaration;
58import org.eclipse.jdt.core.dom.StringLiteral;
59import org.eclipse.jdt.core.dom.SuperConstructorInvocation;
60import org.eclipse.jdt.core.dom.SuperFieldAccess;
61import org.eclipse.jdt.core.dom.SuperMethodInvocation;
62import org.eclipse.jdt.core.dom.SwitchCase;
63import org.eclipse.jdt.core.dom.SwitchStatement;
64import org.eclipse.jdt.core.dom.SynchronizedStatement;
65import org.eclipse.jdt.core.dom.ThisExpression;
66import org.eclipse.jdt.core.dom.ThrowStatement;
67import org.eclipse.jdt.core.dom.TryStatement;
68import org.eclipse.jdt.core.dom.TypeDeclaration;
69import org.eclipse.jdt.core.dom.TypeDeclarationStatement;
70import org.eclipse.jdt.core.dom.TypeLiteral;
71import org.eclipse.jdt.core.dom.VariableDeclarationExpression;
72import org.eclipse.jdt.core.dom.VariableDeclarationFragment;
73import org.eclipse.jdt.core.dom.VariableDeclarationStatement;
74import org.eclipse.jdt.core.dom.WhileStatement;
75
76/**
77 * Empty implementation of a creator - provided to allow subclasses to override only a subset of methods.
78 * Subclass to provide constraint creation functionality.
79 */
80public class ConstraintCreator {
81
82 public static final ITypeConstraint[] EMPTY_ARRAY= new ITypeConstraint[0];
83
84 /**
85 * @param node the AST node
86 * @return array of type constraints, may be empty
87 * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.AnonymousClassDeclaration)
88 */
89 public ITypeConstraint[] create(AnonymousClassDeclaration node) {
90 return EMPTY_ARRAY;
91 }
92
93 /**
94 * @param node the AST node
95 * @return array of type constraints, may be empty
96 * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.ArrayAccess)
97 */
98 public ITypeConstraint[] create(ArrayAccess node) {
99 return EMPTY_ARRAY;
100 }
101
102 /**
103 * @param node the AST node
104 * @return array of type constraints, may be empty
105 * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.ArrayCreation)
106 */
107 public ITypeConstraint[] create(ArrayCreation node) {
108 return EMPTY_ARRAY;
109 }
110
111 /**
112 * @param node the AST node
113 * @return array of type constraints, may be empty
114 * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.ArrayInitializer)
115 */
116 public ITypeConstraint[] create(ArrayInitializer node) {
117 return EMPTY_ARRAY;
118 }
119
120 /**
121 * @param node the AST node
122 * @return array of type constraints, may be empty
123 * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.ArrayType)
124 */
125 public ITypeConstraint[] create(ArrayType node) {
126 return EMPTY_ARRAY;
127 }
128
129 /**
130 * @param node the AST node
131 * @return array of type constraints, may be empty
132 * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.AssertStatement)
133 */
134 public ITypeConstraint[] create(AssertStatement node) {
135 return EMPTY_ARRAY;
136 }
137
138 /**
139 * @param node the AST node
140 * @return array of type constraints, may be empty
141 * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.Assignment)
142 */
143 public ITypeConstraint[] create(Assignment node) {
144 return EMPTY_ARRAY;
145 }
146
147 /**
148 * @param node the AST node
149 * @return array of type constraints, may be empty
150 * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.Block)
151 */
152 public ITypeConstraint[] create(Block node) {
153 return EMPTY_ARRAY;
154 }
155
156 /**
157 * @param node the AST node
158 * @return array of type constraints, may be empty
159 * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.BooleanLiteral)
160 */
161 public ITypeConstraint[] create(BooleanLiteral node) {
162 return EMPTY_ARRAY;
163 }
164
165 /**
166 * @param node the AST node
167 * @return array of type constraints, may be empty
168 * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.BreakStatement)
169 */
170 public ITypeConstraint[] create(BreakStatement node) {
171 return EMPTY_ARRAY;
172 }
173
174 /**
175 * @param node the AST node
176 * @return array of type constraints, may be empty
177 * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.CastExpression)
178 */
179 public ITypeConstraint[] create(CastExpression node) {
180 return EMPTY_ARRAY;
181 }
182
183 /**
184 * @param node the AST node
185 * @return array of type constraints, may be empty
186 * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.CatchClause)
187 */
188 public ITypeConstraint[] create(CatchClause node) {
189 return EMPTY_ARRAY;
190 }
191
192 /**
193 * @param node the AST node
194 * @return array of type constraints, may be empty
195 * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.CharacterLiteral)
196 */
197 public ITypeConstraint[] create(CharacterLiteral node) {
198 return EMPTY_ARRAY;
199 }
200
201 /**
202 * @param node the AST node
203 * @return array of type constraints, may be empty
204 * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.ClassInstanceCreation)
205 */
206 public ITypeConstraint[] create(ClassInstanceCreation node) {
207 return EMPTY_ARRAY;
208 }
209
210 /**
211 * @param node the AST node
212 * @return array of type constraints, may be empty
213 * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.CompilationUnit)
214 */
215 public ITypeConstraint[] create(CompilationUnit node) {
216 return EMPTY_ARRAY;
217 }
218
219 /**
220 * @param node the AST node
221 * @return array of type constraints, may be empty
222 * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.ConditionalExpression)
223 */
224 public ITypeConstraint[] create(ConditionalExpression node) {
225 return EMPTY_ARRAY;
226 }
227
228 /**
229 * @param node the AST node
230 * @return array of type constraints, may be empty
231 * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.ConstructorInvocation)
232 */
233 public ITypeConstraint[] create(ConstructorInvocation node) {
234 return EMPTY_ARRAY;
235 }
236
237 /**
238 * @param node the AST node
239 * @return array of type constraints, may be empty
240 * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.ContinueStatement)
241 */
242 public ITypeConstraint[] create(ContinueStatement node) {
243 return EMPTY_ARRAY;
244 }
245
246 /**
247 * @param node the AST node
248 * @return array of type constraints, may be empty
249 * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.DoStatement)
250 */
251 public ITypeConstraint[] create(DoStatement node) {
252 return EMPTY_ARRAY;
253 }
254
255 /**
256 * @param node the AST node
257 * @return array of type constraints, may be empty
258 * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.EmptyStatement)
259 */
260 public ITypeConstraint[] create(EmptyStatement node) {
261 return EMPTY_ARRAY;
262 }
263
264 /**
265 * @param node the AST node
266 * @return array of type constraints, may be empty
267 * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.ExpressionStatement)
268 */
269 public ITypeConstraint[] create(ExpressionStatement node) {
270 return EMPTY_ARRAY;
271 }
272
273 /**
274 * @param node the AST node
275 * @return array of type constraints, may be empty
276 * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.FieldAccess)
277 */
278 public ITypeConstraint[] create(FieldAccess node) {
279 return EMPTY_ARRAY;
280 }
281
282 /**
283 * @param node the AST node
284 * @return array of type constraints, may be empty
285 * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.FieldDeclaration)
286 */
287 public ITypeConstraint[] create(FieldDeclaration node) {
288 return EMPTY_ARRAY;
289 }
290
291 /**
292 * @param node the AST node
293 * @return array of type constraints, may be empty
294 * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.ForStatement)
295 */
296 public ITypeConstraint[] create(ForStatement node) {
297 return EMPTY_ARRAY;
298 }
299
300 /**
301 * @param node the AST node
302 * @return array of type constraints, may be empty
303 * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.IfStatement)
304 */
305 public ITypeConstraint[] create(IfStatement node) {
306 return EMPTY_ARRAY;
307 }
308
309 /**
310 * @param node the AST node
311 * @return array of type constraints, may be empty
312 * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.ImportDeclaration)
313 */
314 public ITypeConstraint[] create(ImportDeclaration node) {
315 return EMPTY_ARRAY;
316 }
317
318 /**
319 * @param node the AST node
320 * @return array of type constraints, may be empty
321 * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.InfixExpression)
322 */
323 public ITypeConstraint[] create(InfixExpression node) {
324 return EMPTY_ARRAY;
325 }
326
327 /**
328 * @param node the AST node
329 * @return array of type constraints, may be empty
330 * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.Initializer)
331 */
332 public ITypeConstraint[] create(Initializer node) {
333 return EMPTY_ARRAY;
334 }
335
336 /**
337 * @param node the AST node
338 * @return array of type constraints, may be empty
339 * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.InstanceofExpression)
340 */
341 public ITypeConstraint[] create(InstanceofExpression node) {
342 return EMPTY_ARRAY;
343 }
344
345 /**
346 * @param node the AST node
347 * @return array of type constraints, may be empty
348 * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.Javadoc)
349 */
350 public ITypeConstraint[] create(Javadoc node) {
351 return EMPTY_ARRAY;
352 }
353
354 /**
355 * @param node the AST node
356 * @return array of type constraints, may be empty
357 * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.LabeledStatement)
358 */
359 public ITypeConstraint[] create(LabeledStatement node) {
360 return EMPTY_ARRAY;
361 }
362
363 /**
364 * @param node the AST node
365 * @return array of type constraints, may be empty
366 * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.MethodDeclaration)
367 */
368 public ITypeConstraint[] create(MethodDeclaration node) {
369 return EMPTY_ARRAY;
370 }
371
372 /**
373 * @param node the AST node
374 * @return array of type constraints, may be empty
375 * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.MethodInvocation)
376 */
377 public ITypeConstraint[] create(MethodInvocation node) {
378 return EMPTY_ARRAY;
379 }
380
381 /**
382 * @param node the AST node
383 * @return array of type constraints, may be empty
384 * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.NullLiteral)
385 */
386 public ITypeConstraint[] create(NullLiteral node) {
387 return EMPTY_ARRAY;
388 }
389
390 /**
391 * @param node the AST node
392 * @return array of type constraints, may be empty
393 * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.NumberLiteral)
394 */
395 public ITypeConstraint[] create(NumberLiteral node) {
396 return EMPTY_ARRAY;
397 }
398
399 /**
400 * @param node the AST node
401 * @return array of type constraints, may be empty
402 * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.PackageDeclaration)
403 */
404 public ITypeConstraint[] create(PackageDeclaration node) {
405 return EMPTY_ARRAY;
406 }
407
408 /**
409 * @param node the AST node
410 * @return array of type constraints, may be empty
411 * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.ParenthesizedExpression)
412 */
413 public ITypeConstraint[] create(ParenthesizedExpression node) {
414 return EMPTY_ARRAY;
415 }
416
417 /**
418 * @param node the AST node
419 * @return array of type constraints, may be empty
420 * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.PostfixExpression)
421 */
422 public ITypeConstraint[] create(PostfixExpression node) {
423 return EMPTY_ARRAY;
424 }
425
426 /**
427 * @param node the AST node
428 * @return array of type constraints, may be empty
429 * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.PrefixExpression)
430 */
431 public ITypeConstraint[] create(PrefixExpression node) {
432 return EMPTY_ARRAY;
433 }
434
435 /**
436 * @param node the AST node
437 * @return array of type constraints, may be empty
438 * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.PrimitiveType)
439 */
440 public ITypeConstraint[] create(PrimitiveType node) {
441 return EMPTY_ARRAY;
442 }
443
444 /**
445 * @param node the AST node
446 * @return array of type constraints, may be empty
447 * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.QualifiedName)
448 */
449 public ITypeConstraint[] create(QualifiedName node) {
450 return EMPTY_ARRAY;
451 }
452
453 /**
454 * @param node the AST node
455 * @return array of type constraints, may be empty
456 * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.ReturnStatement)
457 */
458 public ITypeConstraint[] create(ReturnStatement node) {
459 return EMPTY_ARRAY;
460 }
461
462 /**
463 * @param node the AST node
464 * @return array of type constraints, may be empty
465 * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.SimpleName)
466 */
467 public ITypeConstraint[] create(SimpleName node) {
468 return EMPTY_ARRAY;
469 }
470
471 /**
472 * @param node the AST node
473 * @return array of type constraints, may be empty
474 * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.SimpleType)
475 */
476 public ITypeConstraint[] create(SimpleType node) {
477 return EMPTY_ARRAY;
478 }
479
480 /**
481 * @param node the AST node
482 * @return array of type constraints, may be empty
483 * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.SingleVariableDeclaration)
484 */
485 public ITypeConstraint[] create(SingleVariableDeclaration node) {
486 return EMPTY_ARRAY;
487 }
488
489 /**
490 * @param node the AST node
491 * @return array of type constraints, may be empty
492 * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.StringLiteral)
493 */
494 public ITypeConstraint[] create(StringLiteral node) {
495 return EMPTY_ARRAY;
496 }
497
498 /**
499 * @param node the AST node
500 * @return array of type constraints, may be empty
501 * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.SuperConstructorInvocation)
502 */
503 public ITypeConstraint[] create(SuperConstructorInvocation node) {
504 return EMPTY_ARRAY;
505 }
506
507 /**
508 * @param node the AST node
509 * @return array of type constraints, may be empty
510 * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.SuperFieldAccess)
511 */
512 public ITypeConstraint[] create(SuperFieldAccess node) {
513 return EMPTY_ARRAY;
514 }
515
516 /**
517 * @param node the AST node
518 * @return array of type constraints, may be empty
519 * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.SuperMethodInvocation)
520 */
521 public ITypeConstraint[] create(SuperMethodInvocation node) {
522 return EMPTY_ARRAY;
523 }
524
525 /**
526 * @param node the AST node
527 * @return array of type constraints, may be empty
528 * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.SwitchCase)
529 */
530 public ITypeConstraint[] create(SwitchCase node) {
531 return EMPTY_ARRAY;
532 }
533
534 /**
535 * @param node the AST node
536 * @return array of type constraints, may be empty
537 * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.SwitchStatement)
538 */
539 public ITypeConstraint[] create(SwitchStatement node) {
540 return EMPTY_ARRAY;
541 }
542
543 /**
544 * @param node the AST node
545 * @return array of type constraints, may be empty
546 * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.SynchronizedStatement)
547 */
548 public ITypeConstraint[] create(SynchronizedStatement node) {
549 return EMPTY_ARRAY;
550 }
551
552 /**
553 * @param node the AST node
554 * @return array of type constraints, may be empty
555 * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.ThisExpression)
556 */
557 public ITypeConstraint[] create(ThisExpression node) {
558 return EMPTY_ARRAY;
559 }
560
561 /**
562 * @param node the AST node
563 * @return array of type constraints, may be empty
564 * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.ThrowStatement)
565 */
566 public ITypeConstraint[] create(ThrowStatement node) {
567 return EMPTY_ARRAY;
568 }
569
570 /**
571 * @param node the AST node
572 * @return array of type constraints, may be empty
573 * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.TryStatement)
574 */
575 public ITypeConstraint[] create(TryStatement node) {
576 return EMPTY_ARRAY;
577 }
578
579 /**
580 * @param node the AST node
581 * @return array of type constraints, may be empty
582 * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.TypeDeclaration)
583 */
584 public ITypeConstraint[] create(TypeDeclaration node) {
585 return EMPTY_ARRAY;
586
587 // TODO account for enums and annotations
588 }
589
590 /**
591 * @param node the AST node
592 * @return array of type constraints, may be empty
593 * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.TypeDeclarationStatement)
594 */
595 public ITypeConstraint[] create(TypeDeclarationStatement node) {
596 return EMPTY_ARRAY;
597 }
598
599 /**
600 * @param node the AST node
601 * @return array of type constraints, may be empty
602 * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.TypeLiteral)
603 */
604 public ITypeConstraint[] create(TypeLiteral node) {
605 return EMPTY_ARRAY;
606 }
607
608 /**
609 * @param node the AST node
610 * @return array of type constraints, may be empty
611 * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.VariableDeclarationExpression)
612 */
613 public ITypeConstraint[] create(VariableDeclarationExpression node) {
614 return EMPTY_ARRAY;
615 }
616
617 /**
618 * @param node the AST node
619 * @return array of type constraints, may be empty
620 * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.VariableDeclarationFragment)
621 */
622 public ITypeConstraint[] create(VariableDeclarationFragment node) {
623 return EMPTY_ARRAY;
624 }
625
626 /**
627 * @param node the AST node
628 * @return array of type constraints, may be empty
629 * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.VariableDeclarationStatement)
630 */
631 public ITypeConstraint[] create(VariableDeclarationStatement node) {
632 return EMPTY_ARRAY;
633 }
634
635 /**
636 * @param node the AST node
637 * @return array of type constraints, may be empty
638 * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.WhileStatement)
639 */
640 public ITypeConstraint[] create(WhileStatement node) {
641 return EMPTY_ARRAY;
642 }
643
644}
Refaktor masterproject