Add freezable macro support

project/Acyclic.scala

@@ -0,0 +1,18 @@
+import sbt.Keys._
+import sbt._
+
+import scala.util.Try
+
+object Acyclic {
+  def settings: Seq[Setting[_]] = Seq(
+    libraryDependencies += "com.lihaoyi" %% "acyclic" % "0.1.7" % "provided",
+    libraryDependencies ++= (
+      if (scalaVersion.value.startsWith("2.10")) Seq(
+        "org.scala-lang" % "scala-compiler" % scalaVersion.value % "provided"
+      ) else Nil
+    ),
+    autoCompilerPlugins := true,
+    addCompilerPlugin("com.lihaoyi" %% "acyclic" % "0.1.7")
+  )
+}
+

project/Common.scala

@@ -21,7 +21,7 @@ object Common {
     homepage := Some(url("https://scala-debugger.org")),
 
     // Default version when not cross-compiling
-    scalaVersion := "2.10.6",
+    scalaVersion := "2.11.8",
 
     crossScalaVersions := Seq("2.10.6", "2.11.8", "2.12.1"),
 
@@ -135,6 +135,6 @@ object Common {
       else
         Some("releases"  at nexus + "service/local/staging/deploy/maven2")
     }
-  ) ++ Macros.pluginSettings
+  ) ++ Macros.pluginSettings ++ Acyclic.settings
 }
 

project/Macros.scala

@@ -13,10 +13,14 @@ object Macros {
   )
 
   /** Macro-specific project settings. */
-  val settings = pluginSettings ++ Seq(
-    libraryDependencies += {
-      scalaVersion("org.scala-lang" % "scala-reflect" % _).value
-    },
+  val settings: Seq[Setting[_]] = pluginSettings ++ Seq(
+    libraryDependencies ++= Seq(
+      "org.typelevel" %% "macro-compat" % "1.1.1",
+      "com.lihaoyi" %% "scalaparse" % "0.4.4",
+      "org.scala-lang" % "scala-compiler" % scalaVersion.value % "provided",
+      scalaVersion("org.scala-lang" % "scala-reflect" % _).value,
+      "org.scalatest" %% "scalatest" % "3.0.0" % "test,it"
+    ),
 
     libraryDependencies ++= (
       if (scalaVersion.value.startsWith("2.10")) Seq(

scala-debugger-api/project/build.properties

@@ -0,0 +1 @@
+sbt.version=0.13.16

scala-debugger-api/src/main/scala/org/scaladebugger/api/profiles/java/info/JavaInfoProducer.scala

@@ -27,7 +27,7 @@ class JavaInfoProducer extends InfoProducer {
    * @return The profile instance providing an implementation corresponding
    *         to Java
    */
-  override def toJavaInfo: InfoProducer = new JavaInfoProducer
+  override def toJavaInfo: InfoProducer = this
 
   /**
    * Retrieves the event info producer tied to this info producer.

scala-debugger-api/src/main/scala/org/scaladebugger/api/profiles/java/info/JavaThreadInfo.scala

@@ -147,6 +147,9 @@ class JavaThreadInfo(
    */
   override def totalFrames: Int = _threadReference.frameCount()
 
+  protected def newValueConverter(value: Value): ValueConverter =
+    JavaValueConverter.from()
+
   protected def newFrameProfile(
     stackFrame: StackFrame,
     index: Int

scala-debugger-api/src/main/scala/org/scaladebugger/api/profiles/java/info/JavaTypeConverter.scala

@@ -0,0 +1,146 @@
+package org.scaladebugger.api.profiles.java.info
+
+import com.sun.jdi._
+import org.scaladebugger.api.profiles.traits.info._
+import JavaTypeConverter._
+
+object JavaTypeConverter {
+  val DefaultNewReferenceTypeProfile: JavaTypeInfo => ReferenceType => ReferenceTypeInfo =
+    `type` => `type`.infoProducer.newReferenceTypeInfo(
+      `type`.scalaVirtualMachine,
+      _: ReferenceType
+    )
+  val DefaultNewArrayTypeProfile: JavaTypeInfo => ArrayType => ArrayTypeInfo =
+    `type` => `type`.infoProducer.newArrayTypeInfo(
+      `type`.scalaVirtualMachine,
+      _: ArrayType
+    )
+  val DefaultNewClassTypeProfile: JavaTypeInfo => ClassType => ClassTypeInfo =
+    `type` => `type`.infoProducer.newClassTypeInfo(
+      `type`.scalaVirtualMachine,
+      _: ClassType
+    )
+  val DefaultNewInterfaceTypeProfile: JavaTypeInfo => InterfaceType => InterfaceTypeInfo =
+    `type` => `type`.infoProducer.newInterfaceTypeInfo(
+      `type`.scalaVirtualMachine,
+      _: InterfaceType
+    )
+  val DefaultNewPrimitiveTypeProfile: JavaTypeInfo => PrimitiveType => PrimitiveTypeInfo =
+    `type` => `type`.infoProducer.newPrimitiveTypeInfo(
+      `type`.scalaVirtualMachine,
+      _: PrimitiveType
+    )
+  val DefaultNewVoidTypeProfile: JavaTypeInfo => VoidType => PrimitiveTypeInfo =
+    `type` => `type`.infoProducer.newPrimitiveTypeInfo(
+      `type`.scalaVirtualMachine,
+      _: VoidType
+    )
+
+  /**
+   * Creates a new converter from the provided type.
+   * @param `type` The type to convert
+   * @return The converter capable of converting the provided type
+   */
+  def from(`type`: JavaTypeInfo): JavaTypeConverter =
+    new JavaTypeConverter(`type`)()
+}
+
+class JavaTypeConverter private(private val `type`: JavaTypeInfo)(
+  private val newReferenceTypeProfile: ReferenceType => ReferenceTypeInfo =
+    DefaultNewReferenceTypeProfile(`type`),
+  private val newArrayTypeProfile: ArrayType => ArrayTypeInfo =
+    DefaultNewArrayTypeProfile(`type`),
+  private val newClassTypeProfile: ClassType => ClassTypeInfo =
+    DefaultNewClassTypeProfile(`type`),
+  private val newInterfaceTypeProfile: InterfaceType => InterfaceTypeInfo =
+    DefaultNewInterfaceTypeProfile(`type`),
+  private val newPrimitiveTypeProfile: PrimitiveType => PrimitiveTypeInfo =
+    DefaultNewPrimitiveTypeProfile(`type`),
+  private val newVoidTypeProfile: VoidType => PrimitiveTypeInfo =
+    DefaultNewVoidTypeProfile(`type`)
+) extends TypeConverter {
+  /**
+   * Creates a copy of the converter that will use the specified converter
+   * functions over the current instances.
+   * @param newReferenceTypeProfile
+   * @param newArrayTypeProfile
+   * @param newClassTypeProfile
+   * @param newInterfaceTypeProfile
+   * @param newPrimitiveTypeProfile
+   * @param newVoidTypeProfile
+   * @return The new converter instance
+   */
+  def using(
+    newReferenceTypeProfile: ReferenceType => ReferenceTypeInfo = newReferenceTypeProfile,
+    newArrayTypeProfile: ArrayType => ArrayTypeInfo = newArrayTypeProfile,
+    newClassTypeProfile: ClassType => ClassTypeInfo = newClassTypeProfile,
+    newInterfaceTypeProfile: InterfaceType => InterfaceTypeInfo = newInterfaceTypeProfile,
+    newPrimitiveTypeProfile: PrimitiveType => PrimitiveTypeInfo = newPrimitiveTypeProfile,
+    newVoidTypeProfile: VoidType => PrimitiveTypeInfo = newVoidTypeProfile
+  ): JavaTypeConverter = new JavaTypeConverter(`type`)(
+    newReferenceTypeProfile = newReferenceTypeProfile,
+    newArrayTypeProfile = newArrayTypeProfile,
+    newClassTypeProfile = newClassTypeProfile,
+    newInterfaceTypeProfile = newInterfaceTypeProfile,
+    newPrimitiveTypeProfile = newPrimitiveTypeProfile,
+    newVoidTypeProfile = newVoidTypeProfile
+  )
+
+  /**
+   * Returns the type as an array type (profile).
+   *
+   * @return The array type profile wrapping this type
+   */
+  @throws[AssertionError]
+  override def toArrayType: ArrayTypeInfo = {
+    assert(`type`.isArrayType, "Type must be an array type!")
+    newArrayTypeProfile(`type`._type.asInstanceOf[ArrayType])
+  }
+
+  /**
+   * Returns the type as an class type (profile).
+   *
+   * @return The class type profile wrapping this type
+   */
+  @throws[AssertionError]
+  override def toClassType: ClassTypeInfo = {
+    assert(`type`.isClassType, "Type must be a class type!")
+    newClassTypeProfile(`type`._type.asInstanceOf[ClassType])
+  }
+
+  /**
+   * Returns the type as an interface type (profile).
+   *
+   * @return The interface type profile wrapping this type
+   */
+  @throws[AssertionError]
+  override def toInterfaceType: InterfaceTypeInfo = {
+    assert(`type`.isInterfaceType, "Type must be an interface type!")
+    newInterfaceTypeProfile(`type`._type.asInstanceOf[InterfaceType])
+  }
+
+  /**
+   * Returns the type as an reference type (profile).
+   *
+   * @return The reference type profile wrapping this type
+   */
+  @throws[AssertionError]
+  override def toReferenceType: ReferenceTypeInfo = {
+    assert(`type`.isReferenceType, "Type must be a reference type!")
+    newReferenceTypeProfile(`type`._type.asInstanceOf[ReferenceType])
+  }
+
+  /**
+   * Returns the type as an primitive type (profile).
+   *
+   * @return The primitive type profile wrapping this type
+   */
+  @throws[AssertionError]
+  override def toPrimitiveType: PrimitiveTypeInfo = {
+    assert(`type`.isPrimitiveType, "Type must be a primitive type!")
+    `type`._type match {
+      case p: PrimitiveType => newPrimitiveTypeProfile(p)
+      case v: VoidType      => newPrimitiveTypeProfile(v)
+    }
+  }
+}

scala-debugger-api/src/main/scala/org/scaladebugger/api/profiles/java/info/JavaTypeInfo.scala

@@ -22,8 +22,8 @@ object JavaTypeInfo {
  */
 class JavaTypeInfo(
   val scalaVirtualMachine: ScalaVirtualMachine,
-  protected val infoProducer: InfoProducer,
-  private val _type: Type
+  protected[info] val infoProducer: InfoProducer,
+  private[info] val _type: Type
 ) extends TypeInfo {
   /**
    * Returns whether or not this info profile represents the low-level Java
@@ -121,106 +121,6 @@ class JavaTypeInfo(
    */
   override def isNullType: Boolean = _type == null
 
-  /**
-   * Returns the type as an array type (profile).
-   *
-   * @return The array type profile wrapping this type
-   */
-  @throws[AssertionError]
-  override def toArrayType: ArrayTypeInfo = {
-    assert(isArrayType, "Type must be an array type!")
-    newArrayTypeProfile(_type.asInstanceOf[ArrayType])
-  }
-
-  /**
-   * Returns the type as an class type (profile).
-   *
-   * @return The class type profile wrapping this type
-   */
-  @throws[AssertionError]
-  override def toClassType: ClassTypeInfo = {
-    assert(isClassType, "Type must be a class type!")
-    newClassTypeProfile(_type.asInstanceOf[ClassType])
-  }
-
-  /**
-   * Returns the type as an interface type (profile).
-   *
-   * @return The interface type profile wrapping this type
-   */
-  @throws[AssertionError]
-  override def toInterfaceType: InterfaceTypeInfo = {
-    assert(isInterfaceType, "Type must be an interface type!")
-    newInterfaceTypeProfile(_type.asInstanceOf[InterfaceType])
-  }
-
-  /**
-   * Returns the type as an reference type (profile).
-   *
-   * @return The reference type profile wrapping this type
-   */
-  @throws[AssertionError]
-  override def toReferenceType: ReferenceTypeInfo = {
-    assert(isReferenceType, "Type must be a reference type!")
-    newReferenceTypeProfile(_type.asInstanceOf[ReferenceType])
-  }
-
-  /**
-   * Returns the type as an primitive type (profile).
-   *
-   * @return The primitive type profile wrapping this type
-   */
-  @throws[AssertionError]
-  override def toPrimitiveType: PrimitiveTypeInfo = {
-    assert(isPrimitiveType, "Type must be a primitive type!")
-    _type match {
-      case p: PrimitiveType => newPrimitiveTypeProfile(p)
-      case v: VoidType      => newPrimitiveTypeProfile(v)
-    }
-  }
-
   protected def newTypeProfile(_type: Type): TypeInfo =
     infoProducer.newTypeInfo(scalaVirtualMachine, _type)
-
-  protected def newReferenceTypeProfile(
-    referenceType: ReferenceType
-  ): ReferenceTypeInfo = infoProducer.newReferenceTypeInfo(
-    scalaVirtualMachine,
-    referenceType
-  )
-
-  protected def newArrayTypeProfile(
-    arrayType: ArrayType
-  ): ArrayTypeInfo = infoProducer.newArrayTypeInfo(
-    scalaVirtualMachine,
-    arrayType
-  )
-
-  protected def newClassTypeProfile(
-    classType: ClassType
-  ): ClassTypeInfo = infoProducer.newClassTypeInfo(
-    scalaVirtualMachine,
-    classType
-  )
-
-  protected def newInterfaceTypeProfile(
-    interfaceType: InterfaceType
-  ): InterfaceTypeInfo = infoProducer.newInterfaceTypeInfo(
-    scalaVirtualMachine,
-    interfaceType
-  )
-
-  protected def newPrimitiveTypeProfile(
-    primitiveType: PrimitiveType
-  ): PrimitiveTypeInfo = infoProducer.newPrimitiveTypeInfo(
-    scalaVirtualMachine,
-    primitiveType
-  )
-
-  protected def newPrimitiveTypeProfile(
-    voidType: VoidType
-  ): PrimitiveTypeInfo = infoProducer.newPrimitiveTypeInfo(
-    scalaVirtualMachine,
-    voidType
-  )
 }