Merge branch 'extractTrait'

Conflicts: src/org/jetbrains/plugins/scala/lang/psi/impl/base/ScStableCodeReferenceElementImpl.scala
JetBrains · Jun 4, 2014 · 1110d96 · 1110d96
2 parents 07cc202 + b319729
commit 1110d96
Show file tree

Hide file tree

Showing 29 changed files with 1,761 additions and 115 deletions.
diff --git a/META-INF/scala-plugin-common.xml b/META-INF/scala-plugin-common.xml
@@ -1098,10 +1098,15 @@
           <add-to-group group-id="GenerateGroup"/>
         </action>
         <action id="Scala.GenerateCompanionObject"
-              class="org.jetbrains.plugins.scala.codeInsight.generation.ScalaGenerateCompanionObjectAction" text="Companion object"
-              description="Generate companion object">
-        <add-to-group group-id="GenerateGroup"/>
-      </action>
+                class="org.jetbrains.plugins.scala.codeInsight.generation.ScalaGenerateCompanionObjectAction" text="Companion object"
+                description="Generate companion object">
+          <add-to-group group-id="GenerateGroup"/>
+        </action>
+        <action id="Scala.ExtractTrait"
+                class="org.jetbrains.plugins.scala.lang.refactoring.extractTrait.ScalaExtractTraitAction" text="_Trait..."
+                description="Extract trait from the selected class">
+          <add-to-group group-id="IntroduceActionsGroup"/>
+        </action>
       </actions>
 
 </idea-plugin>
diff --git a/src/org/jetbrains/plugins/scala/ScalaBundle.properties b/src/org/jetbrains/plugins/scala/ScalaBundle.properties
@@ -235,6 +235,7 @@ cannot.inline.never.used=Variable is never used.
 cannot.inline.not.simple.pattern=Inline is supported only for simple pattern definitions
 cannot.inline.recursive.function=Inline is not supported for recursive functions
 cannot.inline.anonymous.function=Inline of anonymous functions with arguments is not supported
+0.is.not.a.legal.scala.identifier=''{0}'' is not a legal scala identifier
 ########################################################################################################################
 # FunctionAnnotator
 ########################################################################################################################
@@ -589,3 +590,14 @@ rename.base.member=Rename base member
 rename.only.current.member=Rename only current member
 rename.has.multiple.base.members={0} has multiple base members
 rename.only.in=Rename only in {0} {1}
+extract.trait.title=Extract trait
+extract.trait.name.not.specified=No trait name specified
+extract.trait.top.label.text=Extract trait from:
+extract.trait.name=Trait name:
+extract.trait.package.label=Package for new trait:
+private.member.cannot.be.used.in.extracted.member=Private member {0} cannot be used in the extracted member {1}
+member.of.anonymous.class.cannot.be.used.in.extracted.member=Member {0} of an anonymous class cannot be used in the extracted member {1}
+super.reference.used.in.extracted.member=Extracted member {0} has reference to super, but extracted trait will not have a base class
+type.parameters.for.self.type.not.supported=Extracted trait will have {0} as a self type, but identification of it's type parameters is not supported
+members.to.extract=Members to extract
+extract.abstracts=extract abstracts
diff --git a/src/org/jetbrains/plugins/scala/codeInsight/generation/ui/ScalaMemberInfo.scala b/src/org/jetbrains/plugins/scala/codeInsight/generation/ui/ScalaMemberInfo.scala
@@ -9,43 +9,11 @@ import com.intellij.psi.{PsiModifier, PsiMethod}
 import org.jetbrains.plugins.scala.lang.psi.api.statements.{ScFunction, ScFunctionDefinition, ScFunctionDeclaration}
 import com.intellij.lang.java.JavaLanguage
 import org.jetbrains.plugins.scala.lang.structureView.ScalaElementPresentation
+import org.jetbrains.plugins.scala.lang.refactoring.ui.ScalaMemberInfoBase
 
 /**
  * Nikolay.Tropin
  * 8/20/13
  */
-class ScalaMemberInfo(member: ScNamedElement) extends MemberInfoBase[ScNamedElement](member: ScNamedElement) {
-  member match {
-    case method: PsiMethod =>
-      displayName = ScalaPsiUtil.getMethodPresentableText(method)
-      val (superMethod, containingClass) = method match {
-        case scFun: ScFunction => (scFun.superMethod, scFun.containingClass)
-        case _ => (method.findSuperMethods().headOption, method.getContainingClass)
-      }
-      superMethod match {
-        case Some(m: ScFunctionDefinition) => overrides = java.lang.Boolean.TRUE
-        case Some(m: ScFunctionDeclaration) => overrides = java.lang.Boolean.FALSE
-        case Some(m) if m.getLanguage.isInstanceOf[JavaLanguage] =>
-          //for java only
-          overrides = if (!m.hasModifierProperty(PsiModifier.ABSTRACT)) java.lang.Boolean.TRUE else java.lang.Boolean.FALSE
-        case _ => overrides = null
-      }
-      isStatic = containingClass match {
-        case _: ScObject => true
-        case _: ScTemplateDefinition => false
-        case _ => method.hasModifierProperty(PsiModifier.STATIC)
-      }
-    case clazz: ScTypeDefinition =>
-      displayName = ScalaElementPresentation.getTypeDefinitionPresentableText(clazz)
-      isStatic = clazz.containingClass.isInstanceOf[ScObject]
-      overrides = null
-    case elem: ScNamedElement =>
-      displayName = ScalaElementPresentation.getValOrVarPresentableText(elem)
-      isStatic = false
-      overrides = null
-    case _ =>
-      isStatic = false
-      displayName = ""
-      overrides = null
-  }
-}
+class ScalaMemberInfo(member: ScNamedElement)
+        extends ScalaMemberInfoBase[ScNamedElement](member: ScNamedElement)
diff --git a/src/org/jetbrains/plugins/scala/codeInsight/generation/ui/ScalaMemberSelectionPanel.scala b/src/org/jetbrains/plugins/scala/codeInsight/generation/ui/ScalaMemberSelectionPanel.scala
@@ -1,30 +1,20 @@
 package org.jetbrains.plugins.scala
 package codeInsight.generation.ui
 
-import java.awt.BorderLayout
-import javax.swing.JScrollPane
-import com.intellij.ui.{SeparatorFactory, ScrollPaneFactory}
 import java.util
 import org.jetbrains.plugins.scala.lang.psi.api.toplevel.ScNamedElement
-import com.intellij.refactoring.ui.AbstractMemberSelectionPanel
+import org.jetbrains.plugins.scala.lang.refactoring.ui.ScalaMemberSelectionPanelBase
 
 /**
  * Nikolay.Tropin
- * 8/20/13
+ * 2014-05-28
  */
-class ScalaMemberSelectionPanel(title: String, memberInfo: util.List[ScalaMemberInfo], abstractColumnHeader: String)
-        extends AbstractMemberSelectionPanel[ScNamedElement, ScalaMemberInfo] {
+class ScalaMemberSelectionPanel(title: String,
+                                memberInfo: util.List[ScalaMemberInfo],
+                                abstractColumnHeader: String)
+        extends ScalaMemberSelectionPanelBase[ScNamedElement, ScalaMemberInfo](title, memberInfo, abstractColumnHeader) {
 
-  setLayout(new BorderLayout)
-  private val myTable = createMemberSelectionTable(memberInfo, abstractColumnHeader)
-  val scrollPane: JScrollPane = ScrollPaneFactory.createScrollPane(myTable)
-  add(SeparatorFactory.createSeparator(title, myTable), BorderLayout.NORTH)
-  add(scrollPane, BorderLayout.CENTER)
-
-  protected def createMemberSelectionTable(memberInfos: util.List[ScalaMemberInfo], abstractColumnHeader: String): ScalaMemberSelectionTable =
+  override def createMemberSelectionTable(memberInfos: util.List[ScalaMemberInfo], abstractColumnHeader: String) =
     new ScalaMemberSelectionTable(memberInfos, null, abstractColumnHeader)
 
-  def getTable: ScalaMemberSelectionTable = myTable
-
 }
-
diff --git a/src/org/jetbrains/plugins/scala/codeInsight/generation/ui/ScalaMemberSelectionTable.scala b/src/org/jetbrains/plugins/scala/codeInsight/generation/ui/ScalaMemberSelectionTable.scala
@@ -1,63 +1,12 @@
 package org.jetbrains.plugins.scala
 package codeInsight.generation.ui
 
-import com.intellij.refactoring.ui.AbstractMemberSelectionTable
 import org.jetbrains.plugins.scala.lang.psi.api.toplevel.ScNamedElement
 import com.intellij.refactoring.classMembers.MemberInfoModel
-import javax.swing.Icon
-import com.intellij.ui.RowIcon
-import com.intellij.icons.AllIcons
-import org.jetbrains.plugins.scala.lang.psi.api.statements.ScFunction
-import com.intellij.psi._
-import com.intellij.util.{IconUtil, VisibilityIcons}
-import org.jetbrains.plugins.scala.lang.psi.api.toplevel.typedef.{ScObject, ScMember}
+import org.jetbrains.plugins.scala.lang.refactoring.ui.ScalaMemberSelectionTableBase
+
 
-/**
- * Nikolay.Tropin
- * 8/20/13
- */
 class ScalaMemberSelectionTable(memberInfos: java.util.Collection[ScalaMemberInfo],
                                 memberInfoModel: MemberInfoModel[ScNamedElement, ScalaMemberInfo],
                                 abstractColumnHeader: String)
-        extends AbstractMemberSelectionTable[ScNamedElement, ScalaMemberInfo](memberInfos, memberInfoModel, abstractColumnHeader) {
-
-  def getAbstractColumnValue(memberInfo: ScalaMemberInfo): AnyRef = {
-    memberInfo.getMember match {
-      case member: ScMember if member.containingClass.isInstanceOf[ScObject] => null
-      case member: ScMember if member.hasAbstractModifier && myMemberInfoModel.isFixedAbstract(memberInfo) != null =>
-        myMemberInfoModel.isFixedAbstract(memberInfo)
-      case _ if !myMemberInfoModel.isAbstractEnabled(memberInfo) =>
-        val res: java.lang.Boolean = myMemberInfoModel.isAbstractWhenDisabled(memberInfo)
-        res
-      case _ if memberInfo.isToAbstract => java.lang.Boolean.TRUE
-      case _ => java.lang.Boolean.FALSE
-    }
-  }
-
-  def isAbstractColumnEditable(rowIndex: Int): Boolean = {
-    val info: ScalaMemberInfo = myMemberInfos.get(rowIndex)
-    info.getMember match {
-      case member: ScMember if member.hasAbstractModifier && myMemberInfoModel.isFixedAbstract(info) => false
-      case _ => info.isChecked && myMemberInfoModel.isAbstractEnabled(info)
-    }
-  }
-
-  def setVisibilityIcon(memberInfo: ScalaMemberInfo, icon: RowIcon) {
-    memberInfo.getMember match {
-      case owner: PsiModifierListOwner =>
-        owner.getModifierList match {
-          case mods: PsiModifierList => VisibilityIcons.setVisibilityIcon(mods, icon)
-          case _ => icon.setIcon(IconUtil.getEmptyIcon(true), AbstractMemberSelectionTable.VISIBILITY_ICON_POSITION)
-        }
-      case _ =>
-    }
-  }
-
-  def getOverrideIcon(memberInfo: ScalaMemberInfo): Icon = memberInfo.getMember match {
-    case fun: ScFunction =>
-      if (java.lang.Boolean.TRUE == memberInfo.getOverrides) AllIcons.General.OverridingMethod
-      else if (java.lang.Boolean.FALSE == memberInfo.getOverrides) AllIcons.General.ImplementingMethod
-      else AbstractMemberSelectionTable.EMPTY_OVERRIDE_ICON
-    case _ => AbstractMemberSelectionTable.EMPTY_OVERRIDE_ICON
-  }
-}
+        extends ScalaMemberSelectionTableBase[ScNamedElement, ScalaMemberInfo](memberInfos, memberInfoModel, abstractColumnHeader)
diff --git a/src/org/jetbrains/plugins/scala/extensions/package.scala b/src/org/jetbrains/plugins/scala/extensions/package.scala
@@ -17,6 +17,8 @@ import org.jetbrains.plugins.scala.lang.psi.types.result.TypingContext
 import java.io.Closeable
 import com.intellij.openapi.command.{WriteCommandAction, CommandProcessor}
 import org.jetbrains.annotations.NotNull
+import com.intellij.openapi.progress.{EmptyProgressIndicator, ProgressIndicator, Task, ProgressManager}
+import com.intellij.openapi.progress.util.ProgressWindow
 
 /**
   * Pavel Fatin
@@ -101,6 +103,14 @@ package object extensions {
     })
   }
 
+  def withDisabledPostprocessFormatting[T](project: Project)(body: => T): T = {
+    PostprocessReformattingAspect.getInstance(project).disablePostprocessFormattingInside {
+      new Computable[T] {
+        override def compute(): T = body
+      }
+    }
+  }
+
   def invokeLater[T](body: => T) {
     ApplicationManager.getApplication.invokeLater(new Runnable {
       def run() {

diff --git a/src/org/jetbrains/plugins/scala/lang/psi/impl/ScalaPsiElementFactory.scala b/src/org/jetbrains/plugins/scala/lang/psi/impl/ScalaPsiElementFactory.scala
@@ -863,6 +863,10 @@ object ScalaPsiElementFactory {
     createElementWithContext(text, context, child, Def.parse(_))
   }
 
+  def createDefinitionWithContext(text: String, context: PsiElement, child: PsiElement): ScMember = {
+    createElementWithContext(text, context, child, Def.parse(_))
+  }
+
   def createObjectWithContext(text: String, context: PsiElement, child: PsiElement): ScObject = {
     createElementWithContext(text, context, child, TmplDef.parse(_))
   }

diff --git a/src/org/jetbrains/plugins/scala/lang/psi/impl/base/ScStableCodeReferenceElementImpl.scala b/src/org/jetbrains/plugins/scala/lang/psi/impl/base/ScStableCodeReferenceElementImpl.scala
@@ -19,7 +19,7 @@ import org.jetbrains.plugins.scala.lang.psi.api.base._
 import org.jetbrains.plugins.scala.lang.psi.api.base.patterns.{ScBindingPattern, ScConstructorPattern, ScInfixPattern}
 import org.jetbrains.plugins.scala.lang.psi.api.base.types.{ScInfixTypeElement, ScParameterizedTypeElement, ScSimpleTypeElement}
 import org.jetbrains.plugins.scala.lang.psi.api.expr.{ScSuperReference, ScThisReference}
-import org.jetbrains.plugins.scala.lang.psi.api.statements.{ScMacroDefinition, ScTypeAlias}
+import org.jetbrains.plugins.scala.lang.psi.api.statements.{ScFunction, ScMacroDefinition, ScTypeAlias}
 import org.jetbrains.plugins.scala.lang.psi.api.toplevel.imports._
 import org.jetbrains.plugins.scala.lang.psi.api.toplevel.typedef.ScMember
 import org.jetbrains.plugins.scala.lang.resolve._
@@ -208,6 +208,10 @@ class ScStableCodeReferenceElementImpl(node: ASTNode) extends ScalaPsiElementImp
                 val refToMember = ScalaPsiElementFactory.createReferenceFromText(refToClass.getText + "." + binding.name, getManager)
                 this.replace(refToMember).asInstanceOf[ScReferenceElement]
             }
+          case fun: ScFunction if Seq("unapply", "unapplySeq").contains(fun.name) && ScalaPsiUtil.hasStablePath(fun) =>
+            bindToElement(fun.containingClass)
+          case fun: ScFunction if fun.isConstructor =>
+            bindToElement(fun.containingClass)
           case pckg: PsiPackage => bindToPackage(pckg)
           case _ => throw new IncorrectOperationException(s"Cannot bind to $element")
         }

diff --git a/src/org/jetbrains/plugins/scala/lang/psi/impl/expr/ScReferenceExpressionImpl.scala b/src/org/jetbrains/plugins/scala/lang/psi/impl/expr/ScReferenceExpressionImpl.scala
@@ -85,6 +85,8 @@ class ScReferenceExpressionImpl(node: ASTNode) extends ScalaPsiElementImpl(node)
         this
       case t: ScTypeAlias =>
         throw new IncorrectOperationException("type does not match expected kind")
+      case fun: ScFunction if ScalaPsiUtil.hasStablePath(fun) && fun.name == "apply" =>
+        bindToElement(fun.containingClass)
       case elem: PsiNamedElement =>
         if (refName != elem.name)
           throw new IncorrectOperationException("named element does not match expected name")
@@ -108,7 +110,7 @@ class ScReferenceExpressionImpl(node: ASTNode) extends ScalaPsiElementImpl(node)
           case _ =>
         }
         this
-      case _ => throw new IncorrectOperationException("Cannot bind to anything but class: " + element)
+      case _ => throw new IncorrectOperationException("Cannot bind to element: " + element)
     }
   }
 

diff --git a/src/org/jetbrains/plugins/scala/lang/refactoring/ScalaRefactoringSupportProvider.scala b/src/org/jetbrains/plugins/scala/lang/refactoring/ScalaRefactoringSupportProvider.scala
@@ -14,6 +14,7 @@ import psi.api.base.patterns.ScReferencePattern
 import psi.api.statements._
 import psi.api.base.ScFieldId
 import org.jetbrains.plugins.scala.lang.refactoring.introduceField.ScalaIntroduceFieldFromExpressionHandler
+import org.jetbrains.plugins.scala.lang.refactoring.extractTrait.ScalaExtractTraitHandler
 
 /**
  * User: Alexander Podkhalyuzin