001: /*******************************************************************************
002: * Copyright (c) 2000, 2006 IBM Corporation and others.
003: * All rights reserved. This program and the accompanying materials
004: * are made available under the terms of the Eclipse Public License v1.0
005: * which accompanies this distribution, and is available at
006: * http://www.eclipse.org/legal/epl-v10.html
007: *
008: * Contributors:
009: * IBM Corporation - initial API and implementation
010: *******************************************************************************/package org.eclipse.jdt.internal.corext.refactoring.typeconstraints;
011:
012: import java.util.Arrays;
013: import java.util.LinkedHashSet;
014: import java.util.Set;
015:
016: import org.eclipse.core.runtime.Assert;
017:
018: import org.eclipse.jdt.core.dom.ASTVisitor;
019: import org.eclipse.jdt.core.dom.AnonymousClassDeclaration;
020: import org.eclipse.jdt.core.dom.ArrayAccess;
021: import org.eclipse.jdt.core.dom.ArrayCreation;
022: import org.eclipse.jdt.core.dom.ArrayInitializer;
023: import org.eclipse.jdt.core.dom.ArrayType;
024: import org.eclipse.jdt.core.dom.AssertStatement;
025: import org.eclipse.jdt.core.dom.Assignment;
026: import org.eclipse.jdt.core.dom.Block;
027: import org.eclipse.jdt.core.dom.BooleanLiteral;
028: import org.eclipse.jdt.core.dom.BreakStatement;
029: import org.eclipse.jdt.core.dom.CastExpression;
030: import org.eclipse.jdt.core.dom.CatchClause;
031: import org.eclipse.jdt.core.dom.CharacterLiteral;
032: import org.eclipse.jdt.core.dom.ClassInstanceCreation;
033: import org.eclipse.jdt.core.dom.CompilationUnit;
034: import org.eclipse.jdt.core.dom.ConditionalExpression;
035: import org.eclipse.jdt.core.dom.ConstructorInvocation;
036: import org.eclipse.jdt.core.dom.ContinueStatement;
037: import org.eclipse.jdt.core.dom.DoStatement;
038: import org.eclipse.jdt.core.dom.EmptyStatement;
039: import org.eclipse.jdt.core.dom.ExpressionStatement;
040: import org.eclipse.jdt.core.dom.FieldAccess;
041: import org.eclipse.jdt.core.dom.FieldDeclaration;
042: import org.eclipse.jdt.core.dom.ForStatement;
043: import org.eclipse.jdt.core.dom.IfStatement;
044: import org.eclipse.jdt.core.dom.ImportDeclaration;
045: import org.eclipse.jdt.core.dom.InfixExpression;
046: import org.eclipse.jdt.core.dom.Initializer;
047: import org.eclipse.jdt.core.dom.InstanceofExpression;
048: import org.eclipse.jdt.core.dom.Javadoc;
049: import org.eclipse.jdt.core.dom.LabeledStatement;
050: import org.eclipse.jdt.core.dom.MethodDeclaration;
051: import org.eclipse.jdt.core.dom.MethodInvocation;
052: import org.eclipse.jdt.core.dom.NullLiteral;
053: import org.eclipse.jdt.core.dom.NumberLiteral;
054: import org.eclipse.jdt.core.dom.PackageDeclaration;
055: import org.eclipse.jdt.core.dom.ParenthesizedExpression;
056: import org.eclipse.jdt.core.dom.PostfixExpression;
057: import org.eclipse.jdt.core.dom.PrefixExpression;
058: import org.eclipse.jdt.core.dom.PrimitiveType;
059: import org.eclipse.jdt.core.dom.QualifiedName;
060: import org.eclipse.jdt.core.dom.ReturnStatement;
061: import org.eclipse.jdt.core.dom.SimpleName;
062: import org.eclipse.jdt.core.dom.SimpleType;
063: import org.eclipse.jdt.core.dom.SingleVariableDeclaration;
064: import org.eclipse.jdt.core.dom.StringLiteral;
065: import org.eclipse.jdt.core.dom.SuperConstructorInvocation;
066: import org.eclipse.jdt.core.dom.SuperFieldAccess;
067: import org.eclipse.jdt.core.dom.SuperMethodInvocation;
068: import org.eclipse.jdt.core.dom.SwitchCase;
069: import org.eclipse.jdt.core.dom.SwitchStatement;
070: import org.eclipse.jdt.core.dom.SynchronizedStatement;
071: import org.eclipse.jdt.core.dom.ThisExpression;
072: import org.eclipse.jdt.core.dom.ThrowStatement;
073: import org.eclipse.jdt.core.dom.TryStatement;
074: import org.eclipse.jdt.core.dom.TypeDeclaration;
075: import org.eclipse.jdt.core.dom.TypeDeclarationStatement;
076: import org.eclipse.jdt.core.dom.TypeLiteral;
077: import org.eclipse.jdt.core.dom.VariableDeclarationExpression;
078: import org.eclipse.jdt.core.dom.VariableDeclarationFragment;
079: import org.eclipse.jdt.core.dom.VariableDeclarationStatement;
080: import org.eclipse.jdt.core.dom.WhileStatement;
081:
082: public final class ConstraintCollector extends ASTVisitor {
083:
084: private final ConstraintCreator fCreator;
085: private final Set fConstraints;
086:
087: public ConstraintCollector() {
088: this (new FullConstraintCreator());
089: }
090:
091: public ConstraintCollector(ConstraintCreator creator) {
092: Assert.isNotNull(creator);
093: fCreator = creator;
094: fConstraints = new LinkedHashSet();
095: }
096:
097: private void add(ITypeConstraint[] constraints) {
098: fConstraints.addAll(Arrays.asList(constraints));
099: }
100:
101: public void clear() {
102: fConstraints.clear();
103: }
104:
105: public ITypeConstraint[] getConstraints() {
106: return (ITypeConstraint[]) fConstraints
107: .toArray(new ITypeConstraint[fConstraints.size()]);
108: }
109:
110: //------------------------- visit methods -------------------------//
111:
112: /* (non-Javadoc)
113: * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.AnonymousClassDeclaration)
114: */
115: public boolean visit(AnonymousClassDeclaration node) {
116: add(fCreator.create(node));
117: return true;
118: }
119:
120: /* (non-Javadoc)
121: * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.ArrayAccess)
122: */
123: public boolean visit(ArrayAccess node) {
124: add(fCreator.create(node));
125: return true;
126: }
127:
128: /* (non-Javadoc)
129: * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.ArrayCreation)
130: */
131: public boolean visit(ArrayCreation node) {
132: add(fCreator.create(node));
133: return true;
134: }
135:
136: /* (non-Javadoc)
137: * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.ArrayInitializer)
138: */
139: public boolean visit(ArrayInitializer node) {
140: add(fCreator.create(node));
141: return true;
142: }
143:
144: /* (non-Javadoc)
145: * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.ArrayType)
146: */
147: public boolean visit(ArrayType node) {
148: add(fCreator.create(node));
149: return true;
150: }
151:
152: /* (non-Javadoc)
153: * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.AssertStatement)
154: */
155: public boolean visit(AssertStatement node) {
156: add(fCreator.create(node));
157: return true;
158: }
159:
160: /* (non-Javadoc)
161: * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.Assignment)
162: */
163: public boolean visit(Assignment node) {
164: add(fCreator.create(node));
165: return true;
166: }
167:
168: /* (non-Javadoc)
169: * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.Block)
170: */
171: public boolean visit(Block node) {
172: add(fCreator.create(node));
173: return true;
174: }
175:
176: /* (non-Javadoc)
177: * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.BooleanLiteral)
178: */
179: public boolean visit(BooleanLiteral node) {
180: add(fCreator.create(node));
181: return true;
182: }
183:
184: /* (non-Javadoc)
185: * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.BreakStatement)
186: */
187: public boolean visit(BreakStatement node) {
188: add(fCreator.create(node));
189: return true;
190: }
191:
192: /* (non-Javadoc)
193: * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.CastExpression)
194: */
195: public boolean visit(CastExpression node) {
196: add(fCreator.create(node));
197: return true;
198: }
199:
200: /* (non-Javadoc)
201: * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.CatchClause)
202: */
203: public boolean visit(CatchClause node) {
204: add(fCreator.create(node));
205: return true;
206: }
207:
208: /* (non-Javadoc)
209: * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.CharacterLiteral)
210: */
211: public boolean visit(CharacterLiteral node) {
212: add(fCreator.create(node));
213: return true;
214: }
215:
216: /* (non-Javadoc)
217: * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.ClassInstanceCreation)
218: */
219: public boolean visit(ClassInstanceCreation node) {
220: add(fCreator.create(node));
221: return true;
222: }
223:
224: /* (non-Javadoc)
225: * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.CompilationUnit)
226: */
227: public boolean visit(CompilationUnit node) {
228: add(fCreator.create(node));
229: return true;
230: }
231:
232: /* (non-Javadoc)
233: * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.ConditionalExpression)
234: */
235: public boolean visit(ConditionalExpression node) {
236: add(fCreator.create(node));
237: return true;
238: }
239:
240: /* (non-Javadoc)
241: * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.ConstructorInvocation)
242: */
243: public boolean visit(ConstructorInvocation node) {
244: add(fCreator.create(node));
245: return true;
246: }
247:
248: /* (non-Javadoc)
249: * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.ContinueStatement)
250: */
251: public boolean visit(ContinueStatement node) {
252: add(fCreator.create(node));
253: return true;
254: }
255:
256: /* (non-Javadoc)
257: * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.DoStatement)
258: */
259: public boolean visit(DoStatement node) {
260: add(fCreator.create(node));
261: return true;
262: }
263:
264: /* (non-Javadoc)
265: * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.EmptyStatement)
266: */
267: public boolean visit(EmptyStatement node) {
268: add(fCreator.create(node));
269: return true;
270: }
271:
272: /* (non-Javadoc)
273: * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.ExpressionStatement)
274: */
275: public boolean visit(ExpressionStatement node) {
276: add(fCreator.create(node));
277: return true;
278: }
279:
280: /* (non-Javadoc)
281: * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.FieldAccess)
282: */
283: public boolean visit(FieldAccess node) {
284: add(fCreator.create(node));
285: return true;
286: }
287:
288: /* (non-Javadoc)
289: * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.FieldDeclaration)
290: */
291: public boolean visit(FieldDeclaration node) {
292: add(fCreator.create(node));
293: return true;
294: }
295:
296: /* (non-Javadoc)
297: * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.ForStatement)
298: */
299: public boolean visit(ForStatement node) {
300: add(fCreator.create(node));
301: return true;
302: }
303:
304: /* (non-Javadoc)
305: * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.IfStatement)
306: */
307: public boolean visit(IfStatement node) {
308: add(fCreator.create(node));
309: return true;
310: }
311:
312: /* (non-Javadoc)
313: * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.ImportDeclaration)
314: */
315: public boolean visit(ImportDeclaration node) {
316: add(fCreator.create(node));
317: return true;
318: }
319:
320: /* (non-Javadoc)
321: * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.InfixExpression)
322: */
323: public boolean visit(InfixExpression node) {
324: add(fCreator.create(node));
325: return true;
326: }
327:
328: /* (non-Javadoc)
329: * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.Initializer)
330: */
331: public boolean visit(Initializer node) {
332: add(fCreator.create(node));
333: return true;
334: }
335:
336: /* (non-Javadoc)
337: * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.InstanceofExpression)
338: */
339: public boolean visit(InstanceofExpression node) {
340: add(fCreator.create(node));
341: return true;
342: }
343:
344: /* (non-Javadoc)
345: * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.Javadoc)
346: */
347: public boolean visit(Javadoc node) {
348: add(fCreator.create(node));
349: return true;
350: }
351:
352: /* (non-Javadoc)
353: * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.LabeledStatement)
354: */
355: public boolean visit(LabeledStatement node) {
356: add(fCreator.create(node));
357: return true;
358: }
359:
360: /* (non-Javadoc)
361: * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.MethodDeclaration)
362: */
363: public boolean visit(MethodDeclaration node) {
364: add(fCreator.create(node));
365: return true;
366: }
367:
368: /* (non-Javadoc)
369: * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.MethodInvocation)
370: */
371: public boolean visit(MethodInvocation node) {
372: add(fCreator.create(node));
373: return true;
374: }
375:
376: /* (non-Javadoc)
377: * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.NullLiteral)
378: */
379: public boolean visit(NullLiteral node) {
380: add(fCreator.create(node));
381: return true;
382: }
383:
384: /* (non-Javadoc)
385: * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.NumberLiteral)
386: */
387: public boolean visit(NumberLiteral node) {
388: add(fCreator.create(node));
389: return true;
390: }
391:
392: /* (non-Javadoc)
393: * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.PackageDeclaration)
394: */
395: public boolean visit(PackageDeclaration node) {
396: add(fCreator.create(node));
397: return true;
398: }
399:
400: /* (non-Javadoc)
401: * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.ParenthesizedExpression)
402: */
403: public boolean visit(ParenthesizedExpression node) {
404: add(fCreator.create(node));
405: return true;
406: }
407:
408: /* (non-Javadoc)
409: * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.PostfixExpression)
410: */
411: public boolean visit(PostfixExpression node) {
412: add(fCreator.create(node));
413: return true;
414: }
415:
416: /* (non-Javadoc)
417: * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.PrefixExpression)
418: */
419: public boolean visit(PrefixExpression node) {
420: add(fCreator.create(node));
421: return true;
422: }
423:
424: /* (non-Javadoc)
425: * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.PrimitiveType)
426: */
427: public boolean visit(PrimitiveType node) {
428: add(fCreator.create(node));
429: return true;
430: }
431:
432: /* (non-Javadoc)
433: * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.QualifiedName)
434: */
435: public boolean visit(QualifiedName node) {
436: add(fCreator.create(node));
437: return true;
438: }
439:
440: /* (non-Javadoc)
441: * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.ReturnStatement)
442: */
443: public boolean visit(ReturnStatement node) {
444: add(fCreator.create(node));
445: return true;
446: }
447:
448: /* (non-Javadoc)
449: * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.SimpleName)
450: */
451: public boolean visit(SimpleName node) {
452: add(fCreator.create(node));
453: return true;
454: }
455:
456: /* (non-Javadoc)
457: * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.SimpleType)
458: */
459: public boolean visit(SimpleType node) {
460: add(fCreator.create(node));
461: return true;
462: }
463:
464: /* (non-Javadoc)
465: * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.SingleVariableDeclaration)
466: */
467: public boolean visit(SingleVariableDeclaration node) {
468: add(fCreator.create(node));
469: return true;
470: }
471:
472: /* (non-Javadoc)
473: * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.StringLiteral)
474: */
475: public boolean visit(StringLiteral node) {
476: add(fCreator.create(node));
477: return true;
478: }
479:
480: /* (non-Javadoc)
481: * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.SuperConstructorInvocation)
482: */
483: public boolean visit(SuperConstructorInvocation node) {
484: add(fCreator.create(node));
485: return true;
486: }
487:
488: /* (non-Javadoc)
489: * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.SuperFieldAccess)
490: */
491: public boolean visit(SuperFieldAccess node) {
492: add(fCreator.create(node));
493: return true;
494: }
495:
496: /* (non-Javadoc)
497: * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.SuperMethodInvocation)
498: */
499: public boolean visit(SuperMethodInvocation node) {
500: add(fCreator.create(node));
501: return true;
502: }
503:
504: /* (non-Javadoc)
505: * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.SwitchCase)
506: */
507: public boolean visit(SwitchCase node) {
508: add(fCreator.create(node));
509: return true;
510: }
511:
512: /* (non-Javadoc)
513: * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.SwitchStatement)
514: */
515: public boolean visit(SwitchStatement node) {
516: add(fCreator.create(node));
517: return true;
518: }
519:
520: /* (non-Javadoc)
521: * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.SynchronizedStatement)
522: */
523: public boolean visit(SynchronizedStatement node) {
524: add(fCreator.create(node));
525: return true;
526: }
527:
528: /* (non-Javadoc)
529: * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.ThisExpression)
530: */
531: public boolean visit(ThisExpression node) {
532: add(fCreator.create(node));
533: return true;
534: }
535:
536: /* (non-Javadoc)
537: * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.ThrowStatement)
538: */
539: public boolean visit(ThrowStatement node) {
540: add(fCreator.create(node));
541: return true;
542: }
543:
544: /* (non-Javadoc)
545: * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.TryStatement)
546: */
547: public boolean visit(TryStatement node) {
548: add(fCreator.create(node));
549: return true;
550: }
551:
552: /* (non-Javadoc)
553: * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.TypeDeclaration)
554: */
555: public boolean visit(TypeDeclaration node) {
556: add(fCreator.create(node));
557: return true;
558:
559: // TODO account for enums and annotations
560: }
561:
562: /* (non-Javadoc)
563: * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.TypeDeclarationStatement)
564: */
565: public boolean visit(TypeDeclarationStatement node) {
566: add(fCreator.create(node));
567: return true;
568: }
569:
570: /* (non-Javadoc)
571: * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.TypeLiteral)
572: */
573: public boolean visit(TypeLiteral node) {
574: add(fCreator.create(node));
575: return true;
576: }
577:
578: /* (non-Javadoc)
579: * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.VariableDeclarationExpression)
580: */
581: public boolean visit(VariableDeclarationExpression node) {
582: add(fCreator.create(node));
583: return true;
584: }
585:
586: /* (non-Javadoc)
587: * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.VariableDeclarationFragment)
588: */
589: public boolean visit(VariableDeclarationFragment node) {
590: add(fCreator.create(node));
591: return true;
592: }
593:
594: /* (non-Javadoc)
595: * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.VariableDeclarationStatement)
596: */
597: public boolean visit(VariableDeclarationStatement node) {
598: add(fCreator.create(node));
599: return true;
600: }
601:
602: /* (non-Javadoc)
603: * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.WhileStatement)
604: */
605: public boolean visit(WhileStatement node) {
606: add(fCreator.create(node));
607: return true;
608: }
609: }
|