Use CompileAnalysis instead of Analysis where applicable

The former is a marker interface and therefore preferred to use.
However, it doesn't have any functionality therefore we can't use it
very often.

org.scala-ide.sdt.core/src/org/scalaide/core/internal/builder/EclipseBuildManager.scala

@@ -1,12 +1,14 @@
 package org.scalaide.core.internal.builder
 
+import java.io.File
+
 import org.eclipse.core.resources.IFile
+import org.eclipse.core.resources.IMarker
 import org.eclipse.core.runtime.IProgressMonitor
 import org.eclipse.core.runtime.SubMonitor
+
+import xsbti.compile.CompileAnalysis
 import xsbti.compile.IncOptions
-import sbt.internal.inc.Analysis
-import java.io.File
-import org.eclipse.core.resources.IMarker
 
 /**
  * Abstraction which exposes sbt compiler to eclipse.
@@ -30,7 +32,7 @@ trait EclipseBuildManager {
   def canTrackDependencies: Boolean
 
   /** Gives back the latest dependencies analysis done by underlying compiler. */
-  def latestAnalysis(incOptions: => IncOptions): Analysis
+  def latestAnalysis(incOptions: => IncOptions): CompileAnalysis
 
   /**
    * Finds build manager which built given file

org.scala-ide.sdt.core/src/org/scalaide/core/internal/builder/zinc/CachingCompiler.scala

@@ -13,7 +13,6 @@ import xsbti.compile.JavaCompiler
 import sbt.internal.inc.IncrementalCompilerImpl
 import xsbti.compile.PerClasspathEntryLookup
 import xsbti.compile.DefinesClass
-import xsbti.compile.CompileAnalysis
 import xsbti.compile.CompileResult
 
 /**
@@ -37,7 +36,7 @@ class CachingCompiler private (cacheFile: File, sbtReporter: Reporter, log: Logg
   def compile(in: SbtInputs, comps: Compilers): Analysis = {
     val lookup = new PerClasspathEntryLookup {
       override def analysis(classpathEntry: File) =
-        in.analysisMap(classpathEntry).asInstanceOf[xsbti.Maybe[CompileAnalysis]]
+        in.analysisMap(classpathEntry)
 
       override def definesClass(classpathEntry: File) = {
         val dc = Locator(classpathEntry)
@@ -60,8 +59,10 @@ class CachingCompiler private (cacheFile: File, sbtReporter: Reporter, log: Logg
   private def cacheAndReturnLastAnalysis(compilationResult: CompileResult): Analysis = {
     if (compilationResult.hasModified)
       MixedAnalyzingCompiler.staticCachedStore(cacheFile).set(compilationResult.analysis, compilationResult.setup)
-    // TODO is this cast safe here?
-    compilationResult.analysis.asInstanceOf[Analysis]
+    compilationResult.analysis match {
+      case a: Analysis => a
+      case a => throw new IllegalStateException(s"object of type `Analysis` was expected but got `${a.getClass}`.")
+    }
   }
 }
 

org.scala-ide.sdt.core/src/org/scalaide/core/internal/builder/zinc/SbtInputs.scala

@@ -13,21 +13,20 @@ import org.scalaide.core.internal.project.ScalaInstallation.scalaInstanceForInst
 import org.scalaide.ui.internal.preferences
 import org.scalaide.util.internal.SettingConverterUtil
 
-import xsbti.compile.ClasspathOptions
-import sbt.internal.inc.classpath.ClasspathUtilities
+import sbt.internal.inc.AnalyzingCompiler
 import sbt.internal.inc.CompilerCache
-import sbt.internal.inc.Analysis
+import sbt.internal.inc.CompilerInterfaceProvider
 import sbt.internal.inc.Locate
+import sbt.internal.inc.classpath.ClasspathUtilities
 import xsbti.Logger
 import xsbti.Maybe
+import xsbti.compile.ClasspathOptions
+import xsbti.compile.CompileAnalysis
 import xsbti.compile.CompileProgress
-import xsbti.compile.CompileOrder
+import xsbti.compile.DefinesClass
 import xsbti.compile.IncOptions
 import xsbti.compile.IncOptionsUtil
-import xsbti.compile.DefinesClass
 import xsbti.compile.MultipleOutput
-import sbt.internal.inc.AnalyzingCompiler
-import sbt.internal.inc.CompilerInterfaceProvider
 
 /** Inputs-like class, but not implementing xsbti.compile.Inputs.
  *
@@ -48,17 +47,17 @@ class SbtInputs(installation: IScalaInstallation,
 
   private val allProjects = project +: project.transitiveDependencies.flatMap(ScalaPlugin().asScalaProject)
 
-  def analysisMap(f: File): Maybe[Analysis] =
+  def analysisMap(f: File): Maybe[CompileAnalysis] =
     if (f.isFile)
-      Maybe.nothing[Analysis]
+      Maybe.nothing[CompileAnalysis]
     else {
       val analysis = allProjects.collectFirst {
         case project if project.buildManager.buildManagerOf(f).nonEmpty =>
           project.buildManager.buildManagerOf(f).get.latestAnalysis(incOptions)
       }
       analysis.map { analysis =>
         Maybe.just(analysis)
-      }.getOrElse(Maybe.nothing[Analysis])
+      }.getOrElse(Maybe.nothing[CompileAnalysis])
     }
 
   def progress = Maybe.just(scalaProgress)
@@ -126,9 +125,9 @@ class SbtInputs(installation: IScalaInstallation,
 
   def javacOptions: Seq[String] = Nil // Not used.
 
-  import CompileOrder._
-  import SettingConverterUtil.convertNameToProperty
-  import preferences.ScalaPluginSettings.compileOrder
+  import org.scalaide.ui.internal.preferences.ScalaPluginSettings.compileOrder
+  import org.scalaide.util.internal.SettingConverterUtil.convertNameToProperty
+  import xsbti.compile.CompileOrder._
 
   def order = project.storage.getString(convertNameToProperty(compileOrder.name)) match {
     case "JavaThenScala" => JavaThenScala