case-study/jdt-after/core refactoring/org/eclipse/jdt/internal/corext/refactoring/typeconstraints/ConstraintCollector.java

   1 /*******************************************************************************
   2  * Copyright (c) 2000, 2011 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  *******************************************************************************/
  11 package org.eclipse.jdt.internal.corext.refactoring.typeconstraints;
  12
  13 import java.util.Arrays;
  14 import java.util.LinkedHashSet;
  15 import java.util.List;
  16 import java.util.Set;
  17
  18 import org.eclipse.core.runtime.Assert;
  19
  20 import org.eclipse.jdt.core.ICompilationUnit;
  21 import org.eclipse.jdt.core.dom.ASTNode;
  22 import org.eclipse.jdt.core.dom.ASTVisitor;
  23 import org.eclipse.jdt.core.dom.AnonymousClassDeclaration;
  24 import org.eclipse.jdt.core.dom.ArrayAccess;
  25 import org.eclipse.jdt.core.dom.ArrayCreation;
  26 import org.eclipse.jdt.core.dom.ArrayInitializer;
  27 import org.eclipse.jdt.core.dom.ArrayType;
  28 import org.eclipse.jdt.core.dom.AssertStatement;
  29 import org.eclipse.jdt.core.dom.Assignment;
  30 import org.eclipse.jdt.core.dom.Block;
  31 import org.eclipse.jdt.core.dom.BooleanLiteral;
  32 import org.eclipse.jdt.core.dom.BreakStatement;
  33 import org.eclipse.jdt.core.dom.CastExpression;
  34 import org.eclipse.jdt.core.dom.CatchClause;
  35 import org.eclipse.jdt.core.dom.CharacterLiteral;
  36 import org.eclipse.jdt.core.dom.ClassInstanceCreation;
  37 import org.eclipse.jdt.core.dom.CompilationUnit;
  38 import org.eclipse.jdt.core.dom.ConditionalExpression;
  39 import org.eclipse.jdt.core.dom.ConstructorInvocation;
  40 import org.eclipse.jdt.core.dom.ContinueStatement;
  41 import org.eclipse.jdt.core.dom.DoStatement;
  42 import org.eclipse.jdt.core.dom.EmptyStatement;
  43 import org.eclipse.jdt.core.dom.ExpressionStatement;
  44 import org.eclipse.jdt.core.dom.FieldAccess;
  45 import org.eclipse.jdt.core.dom.FieldDeclaration;
  46 import org.eclipse.jdt.core.dom.ForStatement;
  47 import org.eclipse.jdt.core.dom.IfStatement;
  48 import org.eclipse.jdt.core.dom.ImportDeclaration;
  49 import org.eclipse.jdt.core.dom.InfixExpression;
  50 import org.eclipse.jdt.core.dom.Initializer;
  51 import org.eclipse.jdt.core.dom.InstanceofExpression;
  52 import org.eclipse.jdt.core.dom.Javadoc;
  53 import org.eclipse.jdt.core.dom.LabeledStatement;
  54 import org.eclipse.jdt.core.dom.MarkerAnnotation;
  55 import org.eclipse.jdt.core.dom.MethodDeclaration;
  56 import org.eclipse.jdt.core.dom.MethodInvocation;
  57 import org.eclipse.jdt.core.dom.NormalAnnotation;
  58 import org.eclipse.jdt.core.dom.NullLiteral;
  59 import org.eclipse.jdt.core.dom.NumberLiteral;
  60 import org.eclipse.jdt.core.dom.PackageDeclaration;
  61 import org.eclipse.jdt.core.dom.ParenthesizedExpression;
  62 import org.eclipse.jdt.core.dom.PostfixExpression;
  63 import org.eclipse.jdt.core.dom.PrefixExpression;
  64 import org.eclipse.jdt.core.dom.PrimitiveType;
  65 import org.eclipse.jdt.core.dom.QualifiedName;
  66 import org.eclipse.jdt.core.dom.ReturnStatement;
  67 import org.eclipse.jdt.core.dom.SimpleName;
  68 import org.eclipse.jdt.core.dom.SimpleType;
  69 import org.eclipse.jdt.core.dom.SingleMemberAnnotation;
  70 import org.eclipse.jdt.core.dom.SingleVariableDeclaration;
  71 import org.eclipse.jdt.core.dom.StringLiteral;
  72 import org.eclipse.jdt.core.dom.SuperConstructorInvocation;
  73 import org.eclipse.jdt.core.dom.SuperFieldAccess;
  74 import org.eclipse.jdt.core.dom.SuperMethodInvocation;
  75 import org.eclipse.jdt.core.dom.SwitchCase;
  76 import org.eclipse.jdt.core.dom.SwitchStatement;
  77 import org.eclipse.jdt.core.dom.SynchronizedStatement;
  78 import org.eclipse.jdt.core.dom.ThisExpression;
  79 import org.eclipse.jdt.core.dom.ThrowStatement;
  80 import org.eclipse.jdt.core.dom.TryStatement;
  81 import org.eclipse.jdt.core.dom.TypeDeclaration;
  82 import org.eclipse.jdt.core.dom.TypeDeclarationStatement;
  83 import org.eclipse.jdt.core.dom.TypeLiteral;
  84 import org.eclipse.jdt.core.dom.VariableDeclarationExpression;
  85 import org.eclipse.jdt.core.dom.VariableDeclarationFragment;
  86 import org.eclipse.jdt.core.dom.VariableDeclarationStatement;
  87 import org.eclipse.jdt.core.dom.WhileStatement;
  88
  89 import org.eclipse.jdt.internal.corext.refactoring.SearchResultGroup;
  90 import org.eclipse.jdt.internal.corext.refactoring.structure.ASTNodeSearchUtil;
  91 import org.eclipse.jdt.internal.corext.refactoring.structure.ChangeTypeRefactoring;
  92
  93
  94 public final class ConstraintCollector extends ASTVisitor {
  95
  96         private final ConstraintCreator fCreator;
  97         private final Set<ITypeConstraint> fConstraints;
  98
  99         public ConstraintCollector() {
 100                 this(new FullConstraintCreator());
 101         }
 102
 103         public ConstraintCollector(ConstraintCreator creator) {
 104                 Assert.isNotNull(creator);
 105                 fCreator= creator;
 106                 fConstraints= new LinkedHashSet<ITypeConstraint>();
 107         }
 108
 109         private void add(ITypeConstraint[] constraints){
 110                 fConstraints.addAll(Arrays.asList(constraints));
 111         }
 112
 113         public void clear(){
 114                 fConstraints.clear();
 115         }
 116
 117         public ITypeConstraint[] getConstraints(){
 118                 return fConstraints.toArray(new ITypeConstraint[fConstraints.size()]);
 119         }
 120
 121         //------------------------- visit methods -------------------------//
 122
 123         /* (non-Javadoc)
 124          * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.AnonymousClassDeclaration)
 125          */
 126         @Override
 127         public boolean visit(AnonymousClassDeclaration node) {
 128                 add(fCreator.create(node));
 129                 return true;
 130         }
 131
 132         /* (non-Javadoc)
 133          * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.ArrayAccess)
 134          */
 135         @Override
 136         public boolean visit(ArrayAccess node) {
 137                 add(fCreator.create(node));
 138                 return true;
 139         }
 140
 141         /* (non-Javadoc)
 142          * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.ArrayCreation)
 143          */
 144         @Override
 145         public boolean visit(ArrayCreation node) {
 146                 add(fCreator.create(node));
 147                 return true;
 148         }
 149
 150         /* (non-Javadoc)
 151          * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.ArrayInitializer)
 152          */
 153         @Override
 154         public boolean visit(ArrayInitializer node) {
 155                 add(fCreator.create(node));
 156                 return true;
 157         }
 158
 159         /* (non-Javadoc)
 160          * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.ArrayType)
 161          */
 162         @Override
 163         public boolean visit(ArrayType 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.AssertStatement)
 170          */
 171         @Override
 172         public boolean visit(AssertStatement node) {
 173                 add(fCreator.create(node));
 174                 return true;
 175         }
 176
 177         /* (non-Javadoc)
 178          * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.Assignment)
 179          */
 180         @Override
 181         public boolean visit(Assignment node) {
 182                 add(fCreator.create(node));
 183                 return true;
 184         }
 185
 186         /* (non-Javadoc)
 187          * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.Block)
 188          */
 189         @Override
 190         public boolean visit(Block node) {
 191                 add(fCreator.create(node));
 192                 return true;
 193         }
 194
 195         /* (non-Javadoc)
 196          * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.BooleanLiteral)
 197          */
 198         @Override
 199         public boolean visit(BooleanLiteral node) {
 200                 add(fCreator.create(node));
 201                 return true;
 202         }
 203
 204         /* (non-Javadoc)
 205          * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.BreakStatement)
 206          */
 207         @Override
 208         public boolean visit(BreakStatement node) {
 209                 add(fCreator.create(node));
 210                 return true;
 211         }
 212
 213         /* (non-Javadoc)
 214          * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.CastExpression)
 215          */
 216         @Override
 217         public boolean visit(CastExpression node) {
 218                 add(fCreator.create(node));
 219                 return true;
 220         }
 221
 222         /* (non-Javadoc)
 223          * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.CatchClause)
 224          */
 225         @Override
 226         public boolean visit(CatchClause node) {
 227                 add(fCreator.create(node));
 228                 return true;
 229         }
 230
 231         /* (non-Javadoc)
 232          * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.CharacterLiteral)
 233          */
 234         @Override
 235         public boolean visit(CharacterLiteral 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.ClassInstanceCreation)
 242          */
 243         @Override
 244         public boolean visit(ClassInstanceCreation node) {
 245                 add(fCreator.create(node));
 246                 return true;
 247         }
 248
 249         /* (non-Javadoc)
 250          * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.CompilationUnit)
 251          */
 252         @Override
 253         public boolean visit(CompilationUnit node) {
 254                 add(fCreator.create(node));
 255                 return true;
 256         }
 257
 258         /* (non-Javadoc)
 259          * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.ConditionalExpression)
 260          */
 261         @Override
 262         public boolean visit(ConditionalExpression node) {
 263                 add(fCreator.create(node));
 264                 return true;
 265         }
 266
 267         /* (non-Javadoc)
 268          * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.ConstructorInvocation)
 269          */
 270         @Override
 271         public boolean visit(ConstructorInvocation node) {
 272                 add(fCreator.create(node));
 273                 return true;
 274         }
 275
 276         /* (non-Javadoc)
 277          * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.ContinueStatement)
 278          */
 279         @Override
 280         public boolean visit(ContinueStatement node) {
 281                 add(fCreator.create(node));
 282                 return true;
 283         }
 284
 285         /* (non-Javadoc)
 286          * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.DoStatement)
 287          */
 288         @Override
 289         public boolean visit(DoStatement node) {
 290                 add(fCreator.create(node));
 291                 return true;
 292         }
 293
 294         /* (non-Javadoc)
 295          * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.EmptyStatement)
 296          */
 297         @Override
 298         public boolean visit(EmptyStatement node) {
 299                 add(fCreator.create(node));
 300                 return true;
 301         }
 302
 303         /* (non-Javadoc)
 304          * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.ExpressionStatement)
 305          */
 306         @Override
 307         public boolean visit(ExpressionStatement 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.FieldAccess)
 314          */
 315         @Override
 316         public boolean visit(FieldAccess node) {
 317                 add(fCreator.create(node));
 318                 return true;
 319         }
 320
 321         /* (non-Javadoc)
 322          * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.FieldDeclaration)
 323          */
 324         @Override
 325         public boolean visit(FieldDeclaration node) {
 326                 add(fCreator.create(node));
 327                 return true;
 328         }
 329
 330         /* (non-Javadoc)
 331          * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.ForStatement)
 332          */
 333         @Override
 334         public boolean visit(ForStatement node) {
 335                 add(fCreator.create(node));
 336                 return true;
 337         }
 338
 339         /* (non-Javadoc)
 340          * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.IfStatement)
 341          */
 342         @Override
 343         public boolean visit(IfStatement node) {
 344                 add(fCreator.create(node));
 345                 return true;
 346         }
 347
 348         /* (non-Javadoc)
 349          * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.ImportDeclaration)
 350          */
 351         @Override
 352         public boolean visit(ImportDeclaration node) {
 353                 add(fCreator.create(node));
 354                 return true;
 355         }
 356
 357         /* (non-Javadoc)
 358          * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.InfixExpression)
 359          */
 360         @Override
 361         public boolean visit(InfixExpression node) {
 362                 add(fCreator.create(node));
 363                 return true;
 364         }
 365
 366         /* (non-Javadoc)
 367          * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.Initializer)
 368          */
 369         @Override
 370         public boolean visit(Initializer node) {
 371                 add(fCreator.create(node));
 372                 return true;
 373         }
 374
 375         /* (non-Javadoc)
 376          * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.InstanceofExpression)
 377          */
 378         @Override
 379         public boolean visit(InstanceofExpression 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.Javadoc)
 386          */
 387         @Override
 388         public boolean visit(Javadoc node) {
 389                 add(fCreator.create(node));
 390                 return true;
 391         }
 392
 393         /* (non-Javadoc)
 394          * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.LabeledStatement)
 395          */
 396         @Override
 397         public boolean visit(LabeledStatement node) {
 398                 add(fCreator.create(node));
 399                 return true;
 400         }
 401
 402         /* (non-Javadoc)
 403          * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.MarkerAnnotation)
 404          */
 405         @Override
 406         public boolean visit(MarkerAnnotation node) {
 407                 return false;
 408         }
 409         /* (non-Javadoc)
 410          * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.MethodDeclaration)
 411          */
 412         @Override
 413         public boolean visit(MethodDeclaration node) {
 414                 add(fCreator.create(node));
 415                 return true;
 416         }
 417
 418         /* (non-Javadoc)
 419          * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.MethodInvocation)
 420          */
 421         @Override
 422         public boolean visit(MethodInvocation node) {
 423                 add(fCreator.create(node));
 424                 return true;
 425         }
 426         /* (non-Javadoc)
 427          * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.NormalAnnotation)
 428          */
 429         @Override
 430         public boolean visit(NormalAnnotation node) {
 431                 return false;
 432         }
 433         /* (non-Javadoc)
 434          * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.NullLiteral)
 435          */
 436         @Override
 437         public boolean visit(NullLiteral node) {
 438                 add(fCreator.create(node));
 439                 return true;
 440         }
 441
 442         /* (non-Javadoc)
 443          * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.NumberLiteral)
 444          */
 445         @Override
 446         public boolean visit(NumberLiteral node) {
 447                 add(fCreator.create(node));
 448                 return true;
 449         }
 450
 451         /* (non-Javadoc)
 452          * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.PackageDeclaration)
 453          */
 454         @Override
 455         public boolean visit(PackageDeclaration node) {
 456                 add(fCreator.create(node));
 457                 return true;
 458         }
 459
 460         /* (non-Javadoc)
 461          * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.ParenthesizedExpression)
 462          */
 463         @Override
 464         public boolean visit(ParenthesizedExpression node) {
 465                 add(fCreator.create(node));
 466                 return true;
 467         }
 468
 469         /* (non-Javadoc)
 470          * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.PostfixExpression)
 471          */
 472         @Override
 473         public boolean visit(PostfixExpression node) {
 474                 add(fCreator.create(node));
 475                 return true;
 476         }
 477
 478         /* (non-Javadoc)
 479          * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.PrefixExpression)
 480          */
 481         @Override
 482         public boolean visit(PrefixExpression node) {
 483                 add(fCreator.create(node));
 484                 return true;
 485         }
 486
 487         /* (non-Javadoc)
 488          * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.PrimitiveType)
 489          */
 490         @Override
 491         public boolean visit(PrimitiveType 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.QualifiedName)
 498          */
 499         @Override
 500         public boolean visit(QualifiedName node) {
 501                 add(fCreator.create(node));
 502                 return true;
 503         }
 504
 505         /* (non-Javadoc)
 506          * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.ReturnStatement)
 507          */
 508         @Override
 509         public boolean visit(ReturnStatement node) {
 510                 add(fCreator.create(node));
 511                 return true;
 512         }
 513
 514         /* (non-Javadoc)
 515          * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.SimpleName)
 516          */
 517         @Override
 518         public boolean visit(SimpleName node) {
 519                 add(fCreator.create(node));
 520                 return true;
 521         }
 522
 523         /* (non-Javadoc)
 524          * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.SimpleType)
 525          */
 526         @Override
 527         public boolean visit(SimpleType node) {
 528                 add(fCreator.create(node));
 529                 return true;
 530         }
 531
 532         /* (non-Javadoc)
 533          * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.SingleMemberAnnotation)
 534          */
 535         @Override
 536         public boolean visit(SingleMemberAnnotation node) {
 537                 return false;
 538         }
 539
 540         /* (non-Javadoc)
 541          * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.SingleVariableDeclaration)
 542          */
 543         @Override
 544         public boolean visit(SingleVariableDeclaration node) {
 545                 add(fCreator.create(node));
 546                 return true;
 547         }
 548
 549         /* (non-Javadoc)
 550          * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.StringLiteral)
 551          */
 552         @Override
 553         public boolean visit(StringLiteral node) {
 554                 add(fCreator.create(node));
 555                 return true;
 556         }
 557
 558         /* (non-Javadoc)
 559          * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.SuperConstructorInvocation)
 560          */
 561         @Override
 562         public boolean visit(SuperConstructorInvocation node) {
 563                 add(fCreator.create(node));
 564                 return true;
 565         }
 566
 567         /* (non-Javadoc)
 568          * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.SuperFieldAccess)
 569          */
 570         @Override
 571         public boolean visit(SuperFieldAccess node) {
 572                 add(fCreator.create(node));
 573                 return true;
 574         }
 575
 576         /* (non-Javadoc)
 577          * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.SuperMethodInvocation)
 578          */
 579         @Override
 580         public boolean visit(SuperMethodInvocation node) {
 581                 add(fCreator.create(node));
 582                 return true;
 583         }
 584
 585         /* (non-Javadoc)
 586          * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.SwitchCase)
 587          */
 588         @Override
 589         public boolean visit(SwitchCase 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.SwitchStatement)
 596          */
 597         @Override
 598         public boolean visit(SwitchStatement node) {
 599                 add(fCreator.create(node));
 600                 return true;
 601         }
 602
 603         /* (non-Javadoc)
 604          * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.SynchronizedStatement)
 605          */
 606         @Override
 607         public boolean visit(SynchronizedStatement node) {
 608                 add(fCreator.create(node));
 609                 return true;
 610         }
 611
 612         /* (non-Javadoc)
 613          * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.ThisExpression)
 614          */
 615         @Override
 616         public boolean visit(ThisExpression node) {
 617                 add(fCreator.create(node));
 618                 return true;
 619         }
 620
 621         /* (non-Javadoc)
 622          * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.ThrowStatement)
 623          */
 624         @Override
 625         public boolean visit(ThrowStatement node) {
 626                 add(fCreator.create(node));
 627                 return true;
 628         }
 629
 630         /* (non-Javadoc)
 631          * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.TryStatement)
 632          */
 633         @Override
 634         public boolean visit(TryStatement node) {
 635                 add(fCreator.create(node));
 636                 return true;
 637         }
 638
 639         /* (non-Javadoc)
 640          * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.TypeDeclaration)
 641          */
 642         @Override
 643         public boolean visit(TypeDeclaration node) {
 644                 add(fCreator.create(node));
 645                 return true;
 646
 647                 // TODO account for enums and annotations
 648         }
 649
 650         /* (non-Javadoc)
 651          * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.TypeDeclarationStatement)
 652          */
 653         @Override
 654         public boolean visit(TypeDeclarationStatement node) {
 655                 add(fCreator.create(node));
 656                 return true;
 657         }
 658
 659         /* (non-Javadoc)
 660          * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.TypeLiteral)
 661          */
 662         @Override
 663         public boolean visit(TypeLiteral node) {
 664                 add(fCreator.create(node));
 665                 return true;
 666         }
 667
 668         /* (non-Javadoc)
 669          * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.VariableDeclarationExpression)
 670          */
 671         @Override
 672         public boolean visit(VariableDeclarationExpression node) {
 673                 add(fCreator.create(node));
 674                 return true;
 675         }
 676
 677         /* (non-Javadoc)
 678          * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.VariableDeclarationFragment)
 679          */
 680         @Override
 681         public boolean visit(VariableDeclarationFragment node) {
 682                 add(fCreator.create(node));
 683                 return true;
 684         }
 685
 686         /* (non-Javadoc)
 687          * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.VariableDeclarationStatement)
 688          */
 689         @Override
 690         public boolean visit(VariableDeclarationStatement node) {
 691                 add(fCreator.create(node));
 692                 return true;
 693         }
 694
 695         /* (non-Javadoc)
 696          * @see org.eclipse.jdt.core.dom.ASTVisitor#visit(org.eclipse.jdt.core.dom.WhileStatement)
 697          */
 698         @Override
 699         public boolean visit(WhileStatement node) {
 700                 add(fCreator.create(node));
 701                 return true;
 702         }
 703
 704         public List<ITypeConstraint> generated_1070897917906180055(ChangeTypeRefactoring changetyperefactoring, ICompilationUnit unit, CompilationUnit cu) {
 705                 if (changetyperefactoring.fMethodBinding != null && changetyperefactoring.fCuToSearchResultGroup.containsKey(unit)){
 706                         SearchResultGroup group= changetyperefactoring.fCuToSearchResultGroup.get(unit);
 707                         ASTNode[] nodes= ASTNodeSearchUtil.getAstNodes(group.getSearchResults(), cu);
 708                         for (int i=0; i < nodes.length; i++){
 709                                 ASTNode node = nodes[i];
 710                                 if (changetyperefactoring.fMethodBinding != null){
 711                                         // find MethodDeclaration above it in the tree
 712                                         ASTNode n= node;
 713                                         while (!(n instanceof MethodDeclaration)){
 714                                                 n = n.getParent();
 715                                         }
 716                                         MethodDeclaration md = (MethodDeclaration)n;
 717                                         md.accept(this);
 718                                 }
 719                         }
 720                 } else {
 721                         cu.accept(this);
 722                 }
 723                 List<ITypeConstraint> constraints= Arrays.asList(getConstraints());
 724                 changetyperefactoring.fConstraintCache.put(unit, constraints);
 725                 return constraints;
 726         }
 727 }