Stack Manager

.gitignore

@@ -9,3 +9,4 @@ build.properties
 .gradletasknamecache
 build/
 lib/
+/gradle.properties

build.gradle

@@ -38,6 +38,10 @@ allprojects {
         version = properties('platformVersion')
         type = properties('platformType')
         plugins = ['java', 'yaml']
+        // Useful plugins to default-install when developing.
+        if (System.properties['DEV_MODE'] == "true") {
+            plugins += ['gradle', 'IdeaVIM:0.58']
+        }
     }
 
     repositories {
@@ -47,7 +51,9 @@ allprojects {
     configurations {
         provided
         compile.extendsFrom provided
+        paradise
     }
+    configurations.paradise.transitive = false
 
     dependencies {
 
@@ -56,7 +62,8 @@ allprojects {
         compile "org.scala-lang:scala-reflect:${scalaVersion}"
         compile "org.scala-lang:scala-library:${scalaVersion}"
 
-        compile "io.estatico:newtype_${scalaBinaryVersion}:0.1.0"
+        paradise "org.scalamacros:paradise_${scalaVersion}:2.1.1"
+        compile "io.estatico:newtype_${scalaBinaryVersion}:0.4.4"
         compile "org.scalaz:scalaz-core_${scalaBinaryVersion}:7.2.17"
         compile "org.yaml:snakeyaml:1.16"
 
@@ -79,6 +86,7 @@ allprojects {
     }
 
     it.tasks.withType(ScalaCompile) {
+        String paradiseJar = configurations.paradise.singleFile.path
         scalaCompileOptions.setAdditionalParameters([
             '-deprecation',
             '-feature',
@@ -98,6 +106,8 @@ allprojects {
             '-Ywarn-unused:patvars',
             '-Ywarn-unused:privates',
             '-Ywarn-value-discard',
+            // Use '-Ymacro-annotations' once moved to scala 2.13
+            "-Xplugin:${paradiseJar}".toString()
         ])
     }
 }

jps-shared/src/com/haskforce/importWizard/stack/StackYaml.scala

@@ -13,6 +13,8 @@ import scala.util.control.NonFatal
 
 /**
  * The parse result of a stack.yaml file.
+ *
+ * TODO: Remove in favor of a PSI interface.
  */
 sealed case class StackYaml(packages: util.List[StackYaml.Package])
 

resources/META-INF/plugin.xml

@@ -13,6 +13,9 @@
   <depends>com.intellij.modules.lang</depends>
   -->
 
+  <depends>com.intellij.modules.java</depends>
+  <depends>com.intellij.modules.externalSystem</depends>
+
   <application-components>
     <!-- Add your application components here -->
   </application-components>
@@ -58,6 +61,11 @@
             description="Finds Cabal packages in your project and imports them as Haskell modules.">
       <add-to-group group-id="ToolsMenu" anchor="first"/>
     </action>
+    <action id="HaskForce.ImportStackProject"
+            class="com.haskforce.haskell.project.externalSystem.stack.ImportStackProjectAction"
+            text="Import Current Project Using Haskell Stack">
+      <add-to-group group-id="ExternalSystem.Actions" anchor="last"/>
+    </action>
   </actions>
 
   <extensions defaultExtensionNs="com.intellij">
@@ -91,6 +99,7 @@
     <!-- Cache-->
     <projectService serviceImplementation="com.haskforce.codeInsight.HaskellCompletionCacheService"/>
     <projectService serviceImplementation="com.haskforce.tooling.ghcPkg.GhcPkgDumpProjectCacheService"/>
+    <projectService serviceImplementation="com.haskforce.tooling.stack.PackageConfigCacheService"/>
 
     <!-- Language injections -->
     <lang.elementManipulator forClass="com.haskforce.psi.HaskellQqblob"
@@ -193,10 +202,38 @@
     <spellchecker.bundledDictionaryProvider
         implementation="com.haskforce.spellchecker.HaskellBundledDictionaryProvider"/>
 
-    <projectImportProvider
-        implementation="com.haskforce.importWizard.stack.StackProjectImportProvider"/>
-    <projectImportBuilder
-        implementation="com.haskforce.importWizard.stack.StackProjectImportBuilder"/>
+
+    <directoryIndexExcludePolicy
+      implementation="com.haskforce.haskell.roots.HaskellDirectoryIndexExcludePolicy"/>
+
+    <!-- Stack support -->
+
+    <!--
+      We take advantage of being able to use the PSI model and other IDE
+      features while performing a stack project import, so we need to
+      do this in-process with the IDE and not via the external system.
+      The out-of-process external system is mostly useful for JVM build tools
+      which may be leaky. We are not leveraging any such JVM tool so doing
+      this in-process is better for us.
+     -->
+    <registryKey
+      key="HASKELL_STACK.system.in.process"
+      defaultValue="true"
+      restartRequired="true"
+      description="Whether IDE should use 'in-process' mode for the Haskell Stack external system"
+    />
+
+    <projectOpenProcessor implementation="com.haskforce.haskell.project.externalSystem.stack.StackProjectOpenProcessor"/>
+    <externalSystemManager implementation="com.haskforce.haskell.project.externalSystem.stack.StackManager"/>
+    <externalIconProvider key="HASKELL_STACK" implementationClass="com.haskforce.haskell.project.externalSystem.stack.StackIconProvider"/>
+    <externalSystemTaskNotificationListener implementation="com.haskforce.haskell.project.externalSystem.stack.StackProjectImportNotificationListener"/>
+    <projectService serviceImplementation="com.haskforce.haskell.project.externalSystem.stack.StackSettings"/>
+    <projectService serviceImplementation="com.haskforce.haskell.project.externalSystem.stack.StackLocalSettings"/>
+
+    <toolWindow
+      id="Stack" anchor="right" icon="/icons/haskell-13px.png"
+      factoryClass="com.haskforce.haskell.project.externalSystem.stack.ui.StackToolWindowFactory"
+    />
 
     <!-- External builder support -->
     <!-- Note that the classpath is needed for plugin deployment to export a zip archive. -->

src/com/haskforce/HaskForceBuildProcessParametersProvider.scala

@@ -3,55 +3,11 @@ package com.haskforce
 import java.util
 
 import com.intellij.compiler.server.BuildProcessParametersProvider
-import com.intellij.openapi.application.PathManager
-import com.intellij.openapi.diagnostic.Logger
-import com.intellij.util.containers.ContainerUtil
-
-import scala.reflect.{ClassTag, classTag}
 
 /**
  * The external builder in jps-plugin needs to have some jars added to its
- * classpath for some classes it uses. We figure out the right jar name
- * by picking a class from that jar and use `PathManager` to resolve the
- * jar for that class. Otherwise, keeping the version numbers updated for
- * the jars becomes cumbersome and error-prone.
+ * classpath for some classes it uses.
  */
 class HaskForceBuildProcessParametersProvider extends BuildProcessParametersProvider {
-
-  override def getClassPath: util.List[String] = {
-    mkList(
-      jarPath[com.intellij.execution.ExecutionException]("platform-ide-util-io"),
-      jarPath[scala.Symbol]("scala-library"),
-      jarPath[scala.reflect.runtime.JavaUniverse]("scala-reflect"),
-      jarPath[scalaz.Scalaz.type]("scalaz-core"),
-      jarPath[org.yaml.snakeyaml.Yaml]("snakeyaml"),
-      jarPath[io.estatico.newtype.NewType]("newtype")
-    )
-  }
-
-  /**
-   * Takes an array of jar names, logs each one, and builds a list to be
-   * added to the external builder classpath.
-   */
-  private def mkList(xs: String*): util.List[String] = {
-    val res = ContainerUtil.immutableList(xs: _*)
-    res.forEach(x => HaskForceBuildProcessParametersProvider.LOG.info(s"Adding jar to builder classpath: $x"))
-    res
-  }
-
-  /**
-   * Resolve a jar from the class supplied `A` type parameter. The `name`
-   * argument is only supplied for debugging purposes.
-   */
-  private def jarPath[A : ClassTag](name: String): String = {
-    val cls = classTag[A].runtimeClass
-    PathManager.getJarPathForClass(cls) match {
-      case null => throw new RuntimeException(s"Failed to find jar path '$name' for class '$cls'")
-      case s => s
-    }
-  }
-}
-
-object HaskForceBuildProcessParametersProvider {
-  private val LOG = Logger.getInstance(getClass)
+  override def getClassPath: util.List[String] = HaskForceRuntime.classPath
 }

src/com/haskforce/HaskForceRuntime.scala

@@ -0,0 +1,42 @@
+package com.haskforce
+
+import java.util
+
+import com.intellij.openapi.application.PathManager
+import com.intellij.util.containers.ContainerUtil
+
+import scala.reflect.{ClassTag, classTag}
+
+object HaskForceRuntime {
+
+  /**
+   * Get the jars that HaskForce uses so we can run HaskForce code
+   * in external JVM processes (external builder, external system, etc.).
+   *
+   * We figure out the right jar names required by HaskForce
+   * by picking a class from that jar and use `PathManager` to resolve the
+   * jar for that class. Otherwise, keeping the version numbers updated for
+   * the jars becomes cumbersome and error-prone.
+   */
+  lazy val classPath: util.List[String] = ContainerUtil.immutableList(
+    jarPath[com.intellij.execution.ExecutionException]("platform-ide-util-io"),
+    jarPath[scala.Symbol]("scala-library"),
+    jarPath[scala.reflect.runtime.JavaUniverse]("scala-reflect"),
+    jarPath[scalaz.Scalaz.type]("scalaz-core"),
+    jarPath[org.yaml.snakeyaml.Yaml]("snakeyaml"),
+    jarPath[io.estatico.newtype.NewType]("newtype"),
+    jarPath[org.jetbrains.yaml.YAMLLanguage]("yaml")
+  )
+
+  /**
+   * Resolve a jar from the class supplied `A` type parameter. The `name`
+   * argument is only supplied for debugging purposes.
+   */
+  private def jarPath[A : ClassTag](name: String): String = {
+    val cls = classTag[A].runtimeClass
+    PathManager.getJarPathForClass(cls) match {
+      case null => throw new RuntimeException(s"Failed to find jar path '$name' for class '$cls'")
+      case s => s
+    }
+  }
+}