EA-32658 - initialize field in method while introduce field
authorMaxim.Medvedev <maxim.medvedev@jetbrains.com>
Tue, 31 Jan 2012 12:35:46 +0000 (16:35 +0400)
committerMaxim.Medvedev <maxim.medvedev@jetbrains.com>
Tue, 31 Jan 2012 13:23:12 +0000 (17:23 +0400)
13 files changed:
plugins/groovy/src/org/jetbrains/plugins/groovy/lang/psi/api/util/GrStatementOwner.java
plugins/groovy/src/org/jetbrains/plugins/groovy/lang/psi/impl/GroovyFileBaseImpl.java
plugins/groovy/src/org/jetbrains/plugins/groovy/lang/psi/impl/statements/blocks/GrBlockImpl.java
plugins/groovy/src/org/jetbrains/plugins/groovy/lang/psi/impl/statements/clauses/GrCaseSectionImpl.java
plugins/groovy/src/org/jetbrains/plugins/groovy/refactoring/GroovyRefactoringBundle.properties
plugins/groovy/src/org/jetbrains/plugins/groovy/refactoring/GroovyRefactoringUtil.java
plugins/groovy/src/org/jetbrains/plugins/groovy/refactoring/extract/ExtractHandlerBase.java
plugins/groovy/src/org/jetbrains/plugins/groovy/refactoring/introduce/GrIntroduceHandlerBase.java
plugins/groovy/src/org/jetbrains/plugins/groovy/refactoring/introduce/field/GrIntroduceFieldHandler.java
plugins/groovy/src/org/jetbrains/plugins/groovy/refactoring/introduce/parameter/GrIntroduceParameterHandler.java
plugins/groovy/test/org/jetbrains/plugins/groovy/refactoring/introduce/field/GrIntroduceFieldTest.java
plugins/groovy/testdata/refactoring/introduceField/InitializeInCurrentMethod.groovy [new file with mode: 0644]
plugins/groovy/testdata/refactoring/introduceField/InitializeInCurrentMethod_after.groovy [new file with mode: 0644]

index 758b2360d6510bdeac9934a5a1be9789266d7ed0..851e6ffa74292a8fe163f30e125805667305c2ee 100644 (file)
@@ -28,6 +28,7 @@ import org.jetbrains.plugins.groovy.lang.psi.api.statements.GrStatement;
  */
 public interface GrStatementOwner extends GroovyPsiElement {
 
+  @NotNull
   GrStatement addStatementBefore(@NotNull GrStatement statement, @Nullable GrStatement anchor) throws IncorrectOperationException;
 
   void removeElements(PsiElement[] elements) throws IncorrectOperationException;
index d4a83cba0ec7754910a216cd6ccffdd7a37ff1ba..8c5f23028ba975173dd89837269d4024958b37d9 100644 (file)
@@ -187,6 +187,7 @@ public abstract class GroovyFileBaseImpl extends PsiFileBase implements GroovyFi
     return findChildrenByClass(GrStatement.class);
   }
 
+  @NotNull
   public GrStatement addStatementBefore(@NotNull GrStatement statement, @Nullable GrStatement anchor) throws IncorrectOperationException {
     final PsiElement result = addBefore(statement, anchor);
     if (anchor != null) {
index a4b905bda2776c25bdb44986d1d9e19d5d92da85..3b187166df1990eab6d2e6c9be611f454004e0f3 100644 (file)
@@ -144,6 +144,7 @@ public abstract class GrBlockImpl extends LazyParseablePsiElement implements GrC
     return result.toArray(new GrStatement[result.size()]);
   }
 
+  @NotNull
   public GrStatement addStatementBefore(@NotNull GrStatement element, @Nullable GrStatement anchor) throws IncorrectOperationException {
     if (anchor == null && getRBrace() == null) {
       throw new IncorrectOperationException();
index f55361a82eddf64d181f069c0eb28587b5670618..dac4361ef6f43c14e3493b34bb877f8dca1c023f 100644 (file)
@@ -74,6 +74,7 @@ public class GrCaseSectionImpl extends GroovyPsiElementImpl implements GrCaseSec
     return findChildrenByClass(GrStatement.class);
   }
 
+  @NotNull
   public GrStatement addStatementBefore(@NotNull GrStatement element, @Nullable GrStatement anchor) throws IncorrectOperationException {
     ASTNode elemNode = element.copy().getNode();
     assert elemNode != null;
index 9ef43f59b460fe7478135f2891e3e22dcbee0b05..41aa8b2332679bd35f7c83ac4aaa5c7ef1910516 100644 (file)
@@ -26,7 +26,6 @@ declare.final=Declare final
 press.escape.to.remove.the.highlighting=Press Escape to remove the highlighting
 specify.the.type.explicitly=Specify the type explicitly
 variable.of.type=Variable of type:
-name.prompt=Name:
 selected.expression.has.void.type=Selected expression has void type
 selected.expression.in.command.expression=Selected expression is part of command expression
 introduced.variable.conflicts.with.parameter.0=Introduced variable will conflict with parameter {0}
@@ -44,14 +43,12 @@ cannot.find.a.single.definition.to.inline.field=No initializer present for the f
 inline.local.command=Inline Variable
 local.varaible.is.lvalue=Variable to be inlined has occurrence as lvalue in assignment
 inline.local.variable.prompt.0.1=Inline local variable ''{0}''?
-inline.field.prompt=Inline field ''{0}''?
 
 ########################################################################################################################
 # Extract method
 ########################################################################################################################
 extract.method.title=Extract Method
 selected.block.should.represent.a.statement.set=Selected block should represent a set of statements or an expression
-cannot.perform.analysis=Code analysis cannot be performed
 multiple.output.values=There are multiple output values for the selected code fragment
 selected.block.contains.invocation.of.another.class.constructor=Selected block contains invocation of another class constructor
 specify.type.label=Specify return &type explicitly
@@ -84,7 +81,6 @@ refactoring.is.not.supported.when.return.statement.interrupts.the.execution.flow
 refactoring.is.not.supported.for.recursive.methods=Refactoring is not supported for recursive methods
 refactoring.cannot.be.applied.to.constructors=Refactoring cannot be applied to constructors
 refactoring.is.not.supported.in.parameter.initializers=Refactoring is not supported in parameter initializers
-multiple.method.inline.is.not.suppored=Multiple method inline is not supported
 inline.method.prompt.0=Inline method ''{0}'' invocation?
 refactoring.is.available.only.for.method.calls=Refactoring is available only for method calls
 method.is.not.accessible.form.context.0=Method {0} used in inlined method is not accessible from call site
@@ -127,7 +123,7 @@ refactored.method.will.cover.closure.property=Refactored method will override cl
 changeSignature.not.throwable.type=Wrong type: ''{0}'' for exception, should extend java.lang.Throwable
 changeSignature.wrong.type.for.exception=Wrong type: ''{0}'' for exception
 changeSignature.no.type.for.exception=Specify a type for exception
-no.occurences.found=No occurences found
+no.occurrences.found=No occurrences found
 expression.is.not.constant=Selected expression is not a constant
 class.does.not.exists=Class {0} does not exists
 class.does.not.exist.in.the.module=Class does not exists in the module. Do you want to create it?
index e79950900934024106fac51b83c73d5324ae9bc4..6b231263878dd7c2afc8b87e0329e80f0546137e 100644 (file)
@@ -35,7 +35,7 @@ import com.intellij.psi.impl.source.tree.LeafPsiElement;
 import com.intellij.psi.tree.IElementType;
 import com.intellij.psi.util.MethodSignature;
 import com.intellij.psi.util.PsiTreeUtil;
-import com.intellij.psi.util.PsiUtilBase;
+import com.intellij.psi.util.PsiUtilCore;
 import com.intellij.util.ArrayUtil;
 import com.intellij.util.IncorrectOperationException;
 import com.intellij.util.ReflectionCache;
@@ -131,10 +131,6 @@ public abstract class GroovyRefactoringUtil {
   }
 
   public static PsiElement[] getExpressionOccurrences(@NotNull PsiElement expr, @NotNull PsiElement scope) {
-    return getExpressionOccurrences(expr, scope, false);
-  }
-
-  public static PsiElement[] getExpressionOccurrences(@NotNull PsiElement expr, @NotNull PsiElement scope, boolean gotoInner) {
     ArrayList<PsiElement> occurrences = new ArrayList<PsiElement>();
     Comparator<PsiElement> comparator = new Comparator<PsiElement>() {
       public int compare(PsiElement element1, PsiElement element2) {
@@ -144,9 +140,7 @@ public abstract class GroovyRefactoringUtil {
             element2 instanceof GrParameter) {
           final String name1 = ((GrParameter) element1).getName();
           final String name2 = ((GrParameter) element2).getName();
-          if (name1 != null && name2 != null) {
-            return name1.compareTo(name2);
-          }
+          return name1.compareTo(name2);
         }
         return 1;
       }
@@ -162,7 +156,7 @@ public abstract class GroovyRefactoringUtil {
     } else {
       collectOccurrences(expr, scope, occurrences, comparator, scope instanceof GrTypeDefinition || scope instanceof GroovyFileBase);
     }
-    return PsiUtilBase.toPsiElementArray(occurrences);
+    return PsiUtilCore.toPsiElementArray(occurrences);
   }
 
 
@@ -192,8 +186,8 @@ public abstract class GroovyRefactoringUtil {
         tempContainer instanceof GrIfStatement;
   }
 
-  public static void sortOccurrences(PsiElement[] occurences) {
-    Arrays.sort(occurences, new Comparator<PsiElement>() {
+  public static void sortOccurrences(PsiElement[] occurrences) {
+    Arrays.sort(occurrences, new Comparator<PsiElement>() {
       public int compare(PsiElement elem1, PsiElement elem2) {
         final int offset1 = elem1.getTextRange().getStartOffset();
         final int offset2 = elem2.getTextRange().getStartOffset();
@@ -302,7 +296,7 @@ public abstract class GroovyRefactoringUtil {
       return new PsiElement[]{parent.getParent()};
     }
 
-    // calcualte children
+    // calculate children
     PsiElement[] children = PsiElement.EMPTY_ARRAY;
     PsiElement psiChild = parent.getFirstChild();
     if (psiChild != null) {
@@ -311,7 +305,7 @@ public abstract class GroovyRefactoringUtil {
         result.add(psiChild);
         psiChild = psiChild.getNextSibling();
       }
-      children = PsiUtilBase.toPsiElementArray(result);
+      children = PsiUtilCore.toPsiElementArray(result);
     }
 
 
@@ -338,7 +332,7 @@ public abstract class GroovyRefactoringUtil {
       }
     }
 
-    return PsiUtilBase.toPsiElementArray(possibleStatements);
+    return PsiUtilCore.toPsiElementArray(possibleStatements);
   }
 
   public static boolean isSuperOrThisCall(GrStatement statement, boolean testForSuper, boolean testForThis) {
@@ -365,7 +359,7 @@ public abstract class GroovyRefactoringUtil {
     }
   }
 
-  public static boolean haswrongContinueStatements(PsiElement element) {
+  public static boolean hasWrongContinueStatements(PsiElement element) {
     ArrayList<GrContinueStatement> vector = new ArrayList<GrContinueStatement>();
     addContinueStatements(element, vector);
     return !vector.isEmpty();
@@ -457,70 +451,6 @@ public abstract class GroovyRefactoringUtil {
     return id;
   }
 
-  public static GrExpression convertJavaExpr2GroovyExpr(PsiElement expr) {
-    final GroovyPsiElementFactory factory = GroovyPsiElementFactory.getInstance(expr.getProject());
-
-    final List<PsiLocalVariable> localVariables = new ArrayList<PsiLocalVariable>();
-    final List<PsiField> fields = new ArrayList<PsiField>();
-    final List<PsiParameter> parameters = new ArrayList<PsiParameter>();
-
-    expr.accept(new JavaRecursiveElementVisitor() {
-      @Override
-      public void visitReferenceExpression(PsiReferenceExpression expression) {
-        final PsiExpression qualifierExpression = expression.getQualifierExpression();
-        if (qualifierExpression != null && !(qualifierExpression instanceof PsiThisExpression)) return;
-
-        PsiElement el = expression.resolve();
-        if (el instanceof PsiField) {
-          fields.add((PsiField)el);
-        }
-        else if (el instanceof PsiParameter) {
-          parameters.add((PsiParameter)el);
-        }
-        else if (el instanceof PsiLocalVariable) {
-          localVariables.add((PsiLocalVariable)el);
-        }
-        super.visitReferenceExpression(expression);
-      }
-    });
-
-    PsiJavaFile file = (PsiJavaFile)expr.getContainingFile();
-
-    StringBuilder cf = new StringBuilder();
-
-    final PsiPackageStatement packageStatement = file.getPackageStatement();
-    if (packageStatement != null) cf.append(packageStatement.getText());
-
-    final PsiImportList importList = file.getImportList();
-    if (importList != null) cf.append(importList.getText());
-
-    cf.append("class A{");
-    for (PsiField field : fields) {
-      cf.append(field.getText());
-    }
-
-    cf.append("void foo(");
-    for (int i = 0, parametersSize = parameters.size() - 1; i < parametersSize; i++) {
-      PsiParameter parameter = parameters.get(i);
-      cf.append(parameter.getText()).append(',');
-    }
-    if (parameters.size() > 0) {
-      cf.append(parameters.get(parameters.size() - 1).getText());
-    }
-    cf.append("){");
-    for (PsiLocalVariable localVariable : localVariables) {
-      cf.append(localVariable.getText());
-    }
-    cf.append("Object _________________ooooooo_______________=");
-    cf.append(expr.getText());
-    cf.append(";}}");
-    final GroovyFile grFile = factory.createGroovyFile(cf.toString(), false, expr);
-
-    final GrMethod method = (GrMethod)grFile.getClasses()[0].getMethods()[0];
-    final GrVariableDeclaration variableDeclaration = (GrVariableDeclaration)method.getBlock().getStatements()[0];
-    return variableDeclaration.getVariables()[0].getInitializerGroovy();
-  }
-
   public static int verifySafeCopyExpression(GrExpression expression) {
     return verifySafeCopyExpressionSubElement(expression);
   }
@@ -649,19 +579,20 @@ public abstract class GroovyRefactoringUtil {
   }
 
   /**
-   *  adds block statement in parent of expr if needed. For Example:
+   *  adds block statement in parent of statement if needed. For Example:
    *    while (true) a=foo()
    *  will be replaced with
    *    while(true) {a=foo()}
-   * @param expr
-   * @return corresponding expr inside block if it has been created or expr itself.
+   * @param statement
+   * @return corresponding statement inside block if it has been created or statement itself.
    * @throws com.intellij.util.IncorrectOperationException
    */
 
-  public static GrExpression addBlockIntoParent(GrExpression expr) throws IncorrectOperationException {
+  @NotNull
+  public static <Type extends PsiElement> Type addBlockIntoParent(@NotNull Type statement) throws IncorrectOperationException {
 
-    PsiElement parent = expr.getParent();
-    PsiElement child = expr;
+    PsiElement parent = statement.getParent();
+    PsiElement child = statement;
     while (!(parent instanceof GrLoopStatement) &&
            !(parent instanceof GrIfStatement) &&
            !(parent instanceof GrVariableDeclarationOwner) &&
@@ -675,11 +606,11 @@ public abstract class GroovyRefactoringUtil {
     }
     assert parent != null;
     if (parent instanceof GrVariableDeclarationOwner) {
-      return expr;
+      return statement;
     }
 
-    GroovyPsiElementFactory factory = GroovyPsiElementFactory.getInstance(expr.getProject());
-    PsiElement tempStmt = expr;
+    GroovyPsiElementFactory factory = GroovyPsiElementFactory.getInstance(statement.getProject());
+    PsiElement tempStmt = statement;
     while (parent != tempStmt.getParent()) {
       tempStmt = tempStmt.getParent();
     }
@@ -697,14 +628,17 @@ public abstract class GroovyRefactoringUtil {
         ifStatement.replaceElseBranch(blockStatement);
       }
     }
-    GrStatement statement = blockStatement.getBlock().addStatementBefore(toAdd, null);
-    if (statement instanceof GrReturnStatement) {
-      expr = ((GrReturnStatement)statement).getReturnValue();
+    GrStatement result = blockStatement.getBlock().addStatementBefore(toAdd, null);
+    if (result instanceof GrReturnStatement) {
+      //noinspection ConstantConditions,unchecked
+      statement = (Type)((GrReturnStatement)result).getReturnValue();
     }
     else {
-      expr = (GrExpression)statement;
+      //noinspection unchecked
+      statement = (Type)result;
     }
-    return expr;
+
+    return statement;
   }
 
   public static boolean isDiamondNewOperator(GrExpression expression) {
index 44060186614dbcf7a9c77050773ae4e8215bf9c1..fd3ed96b3bb02a833ae63332ef3d8a2293d2b720 100644 (file)
@@ -143,7 +143,7 @@ public abstract class ExtractHandlerBase implements RefactoringActionHandler {
 
     for (GrStatement statement : statements) {
       hasInterruptingStatements =
-        GroovyRefactoringUtil.hasWrongBreakStatements(statement) || GroovyRefactoringUtil.haswrongContinueStatements(statement);
+        GroovyRefactoringUtil.hasWrongBreakStatements(statement) || GroovyRefactoringUtil.hasWrongContinueStatements(statement);
       if (hasInterruptingStatements) break;
     }
 
index 6ed7c8e88f1bd6f8044f91cf9ef8256f3f4e4930..0656d2356a73fbc6683d3e81c0148ea60bf12ce7 100644 (file)
@@ -54,7 +54,6 @@ import org.jetbrains.plugins.groovy.lang.psi.util.PsiUtil;
 import org.jetbrains.plugins.groovy.refactoring.GroovyRefactoringBundle;
 import org.jetbrains.plugins.groovy.refactoring.GroovyRefactoringUtil;
 import org.jetbrains.plugins.groovy.refactoring.NameValidator;
-import org.jetbrains.plugins.groovy.refactoring.introduce.field.GrIntroduceFieldHandler;
 
 import java.util.ArrayList;
 import java.util.Collections;
@@ -203,7 +202,7 @@ public abstract class GrIntroduceHandlerBase<Settings extends GrIntroduceSetting
     final PsiElement scope = findScope(expression, variable);
 
     if (variable == null) {
-      final PsiElement[] occurences = findOccurences(expression, scope);
+      final PsiElement[] occurences = findOccurrences(expression, scope);
       return new GrIntroduceContext(project, editor, expression, occurences, scope, variable);
 
     }
@@ -224,10 +223,10 @@ public abstract class GrIntroduceHandlerBase<Settings extends GrIntroduceSetting
     }
   }
 
-  protected PsiElement[] findOccurences(GrExpression expression, PsiElement scope) {
+  protected PsiElement[] findOccurrences(GrExpression expression, PsiElement scope) {
     final PsiElement[] occurrences = GroovyRefactoringUtil.getExpressionOccurrences(PsiUtil.skipParentheses(expression, false), scope);
     if (occurrences == null || occurrences.length == 0) {
-      throw new GrIntroduceRefactoringError(GroovyRefactoringBundle.message("no.occurences.found"));
+      throw new GrIntroduceRefactoringError(GroovyRefactoringBundle.message("no.occurrences.found"));
     }
     return occurrences;
   }
@@ -399,7 +398,8 @@ public abstract class GrIntroduceHandlerBase<Settings extends GrIntroduceSetting
   }
 
   protected static void deleteLocalVar(GrIntroduceContext context) {
-    final GrVariable resolved = GrIntroduceFieldHandler.resolveLocalVar(context);
+    final GrVariable resolved = resolveLocalVar(context);
+
     final PsiElement parent = resolved.getParent();
     if (parent instanceof GrTupleDeclaration) {
       if (((GrTupleDeclaration)parent).getVariables().length == 1) {
index 52fbd2d2e2db371ebbd5fbcf0d72117dc341b1ca..2c9ed9ad1536e304e729baac2374a5af7a5bf5fb 100644 (file)
@@ -29,7 +29,6 @@ import org.jetbrains.plugins.groovy.lang.psi.GrQualifiedReference;
 import org.jetbrains.plugins.groovy.lang.psi.GroovyPsiElementFactory;
 import org.jetbrains.plugins.groovy.lang.psi.api.statements.*;
 import org.jetbrains.plugins.groovy.lang.psi.api.statements.blocks.GrCodeBlock;
-import org.jetbrains.plugins.groovy.lang.psi.api.statements.blocks.GrOpenBlock;
 import org.jetbrains.plugins.groovy.lang.psi.api.statements.expressions.GrAssignmentExpression;
 import org.jetbrains.plugins.groovy.lang.psi.api.statements.expressions.GrExpression;
 import org.jetbrains.plugins.groovy.lang.psi.api.statements.expressions.GrReferenceExpression;
@@ -102,7 +101,7 @@ public class GrIntroduceFieldHandler extends GrIntroduceHandlerBase<GrIntroduceF
 
   @Override
   protected void checkOccurrences(PsiElement[] occurrences) {
-    //notning to do
+    //nothing to do
   }
 
   @Override
@@ -138,6 +137,8 @@ public class GrIntroduceFieldHandler extends GrIntroduceHandlerBase<GrIntroduceF
     }
 
     GrReferenceAdjuster.shortenReferences(added);
+    
+    //var can be invalid if it was removed while initialization
     if (settings.removeLocalVar()) {
       deleteLocalVar(context);
     }
@@ -145,7 +146,7 @@ public class GrIntroduceFieldHandler extends GrIntroduceHandlerBase<GrIntroduceF
     if (settings.replaceAllOccurrences()) {
       GroovyRefactoringUtil.sortOccurrences(context.occurrences);
       for (PsiElement occurrence : context.occurrences) {
-        replaceOccurence(field, occurrence);
+        replaceOccurrence(field, occurrence);
       }
     }
     else {
@@ -153,22 +154,22 @@ public class GrIntroduceFieldHandler extends GrIntroduceHandlerBase<GrIntroduceF
         context.expression.delete();
       }
       else {
-        replaceOccurence(field, context.expression);
+        replaceOccurrence(field, context.expression);
       }
     }
     return field;
   }
 
   @Override
-  protected PsiElement[] findOccurences(GrExpression expression, PsiElement scope) {
-    final PsiElement[] occurences = super.findOccurences(expression, scope);
+  protected PsiElement[] findOccurrences(GrExpression expression, PsiElement scope) {
+    final PsiElement[] occurrences = super.findOccurrences(expression, scope);
     GrTypeDefinition clazz = (GrTypeDefinition)scope;
-    if (shouldBeStatic(expression, clazz)) return occurences;
+    if (shouldBeStatic(expression, clazz)) return occurrences;
 
     List<PsiElement> filtered = new ArrayList<PsiElement>();
-    for (PsiElement occurence : occurences) {
-      if (!shouldBeStatic(occurence, clazz)) {
-        filtered.add(occurence);
+    for (PsiElement occurrence : occurrences) {
+      if (!shouldBeStatic(occurrence, clazz)) {
+        filtered.add(occurrence);
       }
     }
     return ContainerUtil.toArray(filtered, new PsiElement[filtered.size()]);
@@ -180,18 +181,17 @@ public class GrIntroduceFieldHandler extends GrIntroduceHandlerBase<GrIntroduceF
     final GrTypeDefinition scope = (GrTypeDefinition)context.scope;
     final GrMethod method = getContainingMethod(expression, scope);
     LOG.assertTrue(method != null);
-    final GrOpenBlock block = method.getBlock();
-    LOG.assertTrue(block != null);
+
     final GrStatement anchor;
     if (settings.removeLocalVar()) {
-      final GrVariable variable = resolveLocalVar(context);
+      GrVariable variable = resolveLocalVar(context);
       anchor = PsiTreeUtil.getParentOfType(variable, GrStatement.class);
     }
     else {
-      anchor = (GrStatement)findAnchor(context, settings, context.occurrences, block);
+      anchor = (GrStatement)findAnchor(context, settings, context.occurrences, method.getBlock());
     }
 
-    generateAssignment(context, settings, field, anchor, block);
+    generateAssignment(context, settings, field, anchor, method.getBlock());
   }
 
   private static void initializeInConstructor(GrIntroduceContext context, GrIntroduceFieldSettings settings, GrField field) {
@@ -233,8 +233,8 @@ public class GrIntroduceFieldHandler extends GrIntroduceHandlerBase<GrIntroduceF
   private static void generateAssignment(GrIntroduceContext context,
                                          GrIntroduceFieldSettings settings,
                                          GrField field,
-                                         GrStatement anchor,
-                                         final GrOpenBlock block) {
+                                         @Nullable GrStatement anchor,
+                                         GrCodeBlock defaultContainer) {
     final GrExpression initializer;
     if (settings.removeLocalVar()) {
       initializer = extractVarInitializer(context);
@@ -242,10 +242,20 @@ public class GrIntroduceFieldHandler extends GrIntroduceHandlerBase<GrIntroduceF
     else {
       initializer = context.expression;
     }
-    GrAssignmentExpression init = ((GrAssignmentExpression)GroovyPsiElementFactory.getInstance(context.project)
-      .createExpressionFromText(settings.getName() + " = " + initializer.getText()));
+    GrAssignmentExpression init = (GrAssignmentExpression)GroovyPsiElementFactory.getInstance(context.project)
+      .createExpressionFromText(settings.getName() + " = " + initializer.getText());
+
+    GrCodeBlock block;
+    if (anchor != null) {
+      anchor = GroovyRefactoringUtil.addBlockIntoParent(anchor);
+      LOG.assertTrue(anchor.getParent() instanceof GrCodeBlock);
+      block = (GrCodeBlock)anchor.getParent();
+    }
+    else {
+      block = defaultContainer;
+    }
     init = (GrAssignmentExpression)block.addStatementBefore(init, anchor);
-    replaceOccurence(field, init.getLValue());
+    replaceOccurrence(field, init.getLValue());
   }
 
   private static GrExpression extractVarInitializer(GrIntroduceContext context) {
@@ -268,13 +278,13 @@ public class GrIntroduceFieldHandler extends GrIntroduceHandlerBase<GrIntroduceF
     return findAnchor(context, settings, ContainerUtil.toArray(elements, new PsiElement[elements.size()]), block);
   }
 
-  private static void replaceOccurence(GrField field, PsiElement occurence) {
-    final GrReferenceExpression newExpr = createRefExpression(field, occurence);
+  private static void replaceOccurrence(GrField field, PsiElement occurrence) {
+    final GrReferenceExpression newExpr = createRefExpression(field, occurrence);
     final PsiElement replaced;
-    if (occurence instanceof GrExpression) {
-      replaced = ((GrExpression)occurence).replaceWithExpression(newExpr, false);
+    if (occurrence instanceof GrExpression) {
+      replaced = ((GrExpression)occurrence).replaceWithExpression(newExpr, false);
     } else {
-      replaced = occurence.replace(newExpr);
+      replaced = occurrence.replace(newExpr);
     }
     if (replaced instanceof GrQualifiedReference) {
       GrReferenceAdjuster.shortenReference((GrQualifiedReference)replaced);
index 504267ef9fa7f26f32db3cc484a5dd0eba066af8..5a77e49bea3e81969aa2a6c0a53da11d94e20856 100644 (file)
@@ -221,9 +221,9 @@ public class GrIntroduceParameterHandler implements RefactoringActionHandler, Me
     final PsiElement expr = PsiUtil.skipParentheses(expression, false);
     if (expr == null) return PsiElement.EMPTY_ARRAY;
 
-    final PsiElement[] occurrences = GroovyRefactoringUtil.getExpressionOccurrences(expr, scope, true);
+    final PsiElement[] occurrences = GroovyRefactoringUtil.getExpressionOccurrences(expr, scope);
     if (occurrences == null || occurrences.length == 0) {
-      throw new GrIntroduceRefactoringError(GroovyRefactoringBundle.message("no.occurences.found"));
+      throw new GrIntroduceRefactoringError(GroovyRefactoringBundle.message("no.occurrences.found"));
     }
     return occurrences;
   }
index 5bbfb796e9c0824392cfc097d83215b150f75874..959f4a8742ad8a7435b1ee9849ffd6d376c2e391 100644 (file)
@@ -81,6 +81,10 @@ public class GrIntroduceFieldTest extends LightCodeInsightFixtureTestCase {
   public void testAnonymous3() {
     doTest(false, false, false, CONSTRUCTOR, false, null);
   }
+  
+  public void testInitializeInCurrentMethod() {
+    doTest(false, true, true, CUR_METHOD, false, null);
+  }
 
   private void doTest(final boolean isStatic,
                       final boolean removeLocal,
diff --git a/plugins/groovy/testdata/refactoring/introduceField/InitializeInCurrentMethod.groovy b/plugins/groovy/testdata/refactoring/introduceField/InitializeInCurrentMethod.groovy
new file mode 100644 (file)
index 0000000..290cb9c
--- /dev/null
@@ -0,0 +1,8 @@
+class X {
+    def foo() {
+        if (true) {
+            String i = "5"
+            ptint <selection>i</selection>
+        }
+    }
+}
diff --git a/plugins/groovy/testdata/refactoring/introduceField/InitializeInCurrentMethod_after.groovy b/plugins/groovy/testdata/refactoring/introduceField/InitializeInCurrentMethod_after.groovy
new file mode 100644 (file)
index 0000000..e126a9b
--- /dev/null
@@ -0,0 +1,10 @@
+class X {
+    final def f
+
+    def foo() {
+        if (true) {
+            f = "5"
+            ptint <selection>f</selection>
+        }
+    }
+}