Merge branch 'develop' into feature/method-chaining

Author: swissiety

boomerangScope-Opal/pom.xml

@@ -21,7 +21,6 @@
     </scm>
 
     <properties>
-        <opal.version>5.0.0</opal.version>
         <license.dir>${project.parent.basedir}</license.dir>
     </properties>
 
@@ -68,6 +67,11 @@
             <artifactId>three-address-code_2.13</artifactId>
             <version>${opal.version}</version>
         </dependency>
+        <dependency>
+            <groupId>de.opal-project</groupId>
+            <artifactId>static-analysis-infrastructure_2.13</artifactId>
+            <version>${opal.version}</version>
+        </dependency>
 
         <dependency>
             <groupId>com.google.guava</groupId>

boomerangScope-Opal/src/main/scala/boomerang/scope/opal/OpalScopeConverter.scala

@@ -29,10 +29,10 @@ import boomerang.scope.opal.tac.OpalType
 import boomerang.scope.opal.tac.OpalVal
 import boomerang.scope.opal.tac.OpalWrappedClass
 import boomerang.scope.opal.transformation.TacLocal
+import org.opalj.br.ClassType
 import org.opalj.br.FieldType
 import org.opalj.br.Method
 import org.opalj.br.MethodDescriptor
-import org.opalj.br.ObjectType
 import org.opalj.br.analyses.Project
 import org.opalj.tac.Expr
 import org.opalj.tac.Stmt
@@ -52,7 +52,7 @@ object OpalScopeConverter {
    * @param name the field's name
    * @return the field object in Boomerang's Opal scope
    */
-  def createOpalField(declaringClass: ObjectType, fieldType: FieldType, name: String) =
+  def createOpalField(declaringClass: ClassType, fieldType: FieldType, name: String) =
     new OpalField(declaringClass, fieldType, name)
 
   /**
@@ -100,7 +100,7 @@ object OpalScopeConverter {
    * @return the method object in Boomerang's Soot scope
    */
   def createOpalPhantomMethod(
-      declaringClassType: ObjectType,
+      declaringClassType: ClassType,
       name: String,
       descriptor: MethodDescriptor,
       static: Boolean,
@@ -206,24 +206,24 @@ object OpalScopeConverter {
   }
 
   /**
-   * Create an [[OpalWrappedClass]] from an [[ObjectType]]. The returned object represents a
+   * Create an [[OpalWrappedClass]] from an [[ClassType]]. The returned object represents a
    * class in Boomerang's Opal scope.
    *
    * @param objectType the object type containing relevant class information
    * @param project    the project containing the class type
    * @return the class object in Boomerang's Opal scope
    */
-  def createOpalWrappedClass(objectType: ObjectType, project: Project[_]) =
+  def createOpalWrappedClass(objectType: ClassType, project: Project[_]) =
     new OpalWrappedClass(objectType, project)
 
   /**
-   * Extract the delegated [[ObjectType]] from a [[WrappedClass]]. This requires the type to
+   * Extract the delegated [[ClassType]] from a [[WrappedClass]]. This requires the type to
    * be an [[OpalWrappedClass]].
    *
-   * @param wrappedClass the [[OpalWrappedClass]] to extract the [[ObjectType]] from
-   * @return the delegated [[ObjectType]]
+   * @param wrappedClass the [[OpalWrappedClass]] to extract the [[ClassType]] from
+   * @return the delegated [[ClassType]]
    */
-  def extractOpalClass(wrappedClass: WrappedClass): ObjectType = wrappedClass match {
+  def extractOpalClass(wrappedClass: WrappedClass): ClassType = wrappedClass match {
     case opalClass: OpalWrappedClass => opalClass.delegate
     case _ => throw new RuntimeException("WrappedClass is not an OpalWrappedClass")
   }

boomerangScope-Opal/src/main/scala/boomerang/scope/opal/tac/OpalDeclaredMethod.scala

@@ -45,7 +45,7 @@ class OpalDeclaredMethod(
   )
 
   override def getDeclaringClass: WrappedClass =
-    new OpalWrappedClass(delegate.declaringClass.mostPreciseObjectType, method.project)
+    new OpalWrappedClass(delegate.declaringClass.mostPreciseClassType, method.project)
 
   override def getParameterTypes: util.List[Type] = {
     val result = new util.ArrayList[Type]()

boomerangScope-Opal/src/main/scala/boomerang/scope/opal/tac/OpalField.scala

@@ -16,11 +16,11 @@ package boomerang.scope.opal.tac
 
 import boomerang.scope.Field
 import java.util.Objects
+import org.opalj.br.ClassType
 import org.opalj.br.FieldType
-import org.opalj.br.ObjectType
 
 class OpalField(
-    val declaringClass: ObjectType,
+    val declaringClass: ClassType,
     val fieldType: FieldType,
     val name: String
 ) extends Field {

boomerangScope-Opal/src/main/scala/boomerang/scope/opal/tac/OpalInstanceFieldRef.scala

@@ -17,13 +17,13 @@ package boomerang.scope.opal.tac
 import boomerang.scope._
 import boomerang.scope.opal.transformation.TacLocal
 import java.util.Objects
+import org.opalj.br.ClassType
 import org.opalj.br.FieldType
-import org.opalj.br.ObjectType
 import org.opalj.tac.Expr
 
 class OpalInstanceFieldRef(
     val objRef: Expr[TacLocal],
-    val declaringClass: ObjectType,
+    val declaringClass: ClassType,
     val fieldType: FieldType,
     val fieldName: String,
     method: OpalMethod,

boomerangScope-Opal/src/main/scala/boomerang/scope/opal/tac/OpalPhantomMethod.scala

@@ -20,13 +20,13 @@ import boomerang.scope.WrappedClass
 import boomerang.scope.opal.OpalFrameworkScope
 import java.util
 import java.util.Objects
+import org.opalj.br.ClassType
 import org.opalj.br.MethodDescriptor
 import org.opalj.br.MethodSignature
-import org.opalj.br.ObjectType
 import org.opalj.br.analyses.Project
 
 class OpalPhantomMethod private (
-    val declaringClassType: ObjectType,
+    val declaringClassType: ClassType,
     val name: String,
     val descriptor: MethodDescriptor,
     val static: Boolean,
@@ -78,7 +78,7 @@ class OpalPhantomMethod private (
 object OpalPhantomMethod {
 
   def of(
-      declaringClassType: ObjectType,
+      declaringClassType: ClassType,
       name: String,
       descriptor: MethodDescriptor,
       static: Boolean,

boomerangScope-Opal/src/main/scala/boomerang/scope/opal/tac/OpalStaticFieldRef.scala

@@ -22,11 +22,11 @@ import boomerang.scope.Type
 import boomerang.scope.Val
 import boomerang.scope.WrappedClass
 import java.util.Objects
+import org.opalj.br.ClassType
 import org.opalj.br.FieldType
-import org.opalj.br.ObjectType
 
 class OpalStaticFieldRef(
-    val declaringClass: ObjectType,
+    val declaringClass: ClassType,
     val fieldType: FieldType,
     val name: String,
     method: OpalMethod,

boomerangScope-Opal/src/main/scala/boomerang/scope/opal/tac/OpalType.scala

@@ -15,11 +15,11 @@
 package boomerang.scope.opal.tac
 
 import boomerang.scope.Type
-import boomerang.scope.Val
 import boomerang.scope.WrappedClass
 import boomerang.scope.opal.transformation.TacLocal
 import java.util.Objects
 import org.opalj.br.ArrayType
+import org.opalj.br.ClassType
 import org.opalj.br.ComputationalType
 import org.opalj.br.ComputationalTypeDouble
 import org.opalj.br.ComputationalTypeFloat
@@ -32,7 +32,6 @@ import org.opalj.br.FieldType
 import org.opalj.br.FloatType
 import org.opalj.br.IntegerType
 import org.opalj.br.LongType
-import org.opalj.br.ObjectType
 import org.opalj.br.analyses.Project
 import org.opalj.tac.ArrayLength
 import org.opalj.tac.ArrayLoad
@@ -65,39 +64,39 @@ class OpalType(val delegate: org.opalj.br.Type, project: Project[_]) extends Typ
 
   override def isNullType: Boolean = false
 
-  override def isRefType: Boolean = delegate.isObjectType
+  override def isRefType: Boolean = delegate.isClassType
 
   override def isArrayType: Boolean = delegate.isArrayType
 
   override def getArrayBaseType: Type = new OpalType(delegate.asArrayType.componentType, project)
 
   override def getWrappedClass: WrappedClass = {
     if (isRefType) {
-      return new OpalWrappedClass(delegate.asReferenceType.mostPreciseObjectType, project)
+      return new OpalWrappedClass(delegate.asReferenceType.mostPreciseClassType, project)
     }
 
     throw new RuntimeException("Class of non reference type not available")
   }
 
   override def isSubtypeOf(otherType: String): Boolean = {
-    if (!delegate.isObjectType) {
+    if (!delegate.isClassType) {
       return false
     }
 
     project.classHierarchy.isSubtypeOf(
-      delegate.asObjectType,
-      ObjectType(otherType.replace(".", "/"))
+      delegate.asClassType,
+      ClassType(otherType.replace(".", "/"))
     )
   }
 
   override def isSupertypeOf(subType: String): Boolean = {
-    if (!delegate.isObjectType) {
+    if (!delegate.isClassType) {
       return false
     }
 
     project.classHierarchy.isSubtypeOf(
-      ObjectType(subType.replace(".", "/")),
-      delegate.asObjectType
+      ClassType(subType.replace(".", "/")),
+      delegate.asClassType
     )
   }
 
@@ -126,7 +125,7 @@ object OpalType {
       case _: LongConst => return new OpalType(LongType, project)
       case _: FloatConst => return new OpalType(FloatType, project)
       case _: DoubleConst => return new OpalType(DoubleType, project)
-      case _: StringConst => return new OpalType(ObjectType.String, project)
+      case _: StringConst => return new OpalType(ClassType.String, project)
       case classConst: ClassConst => return new OpalType(classConst.value, project)
       case dynamicConst: DynamicConst => return new OpalType(dynamicConst.descriptor, project)
       case nullExpr: NullExpr => return new OpalType(nullExpr.tpe, project)
@@ -159,8 +158,8 @@ object OpalType {
       case ComputationalTypeFloat => FloatType
       case ComputationalTypeLong => LongType
       case ComputationalTypeDouble => DoubleType
-      case ComputationalTypeReference => ObjectType.Object
-      case ComputationalTypeReturnAddress => ObjectType.Object
+      case ComputationalTypeReference => ClassType.Object
+      case ComputationalTypeReturnAddress => ClassType.Object
       case _ =>
         throw new RuntimeException("Unknown computational type " + cTpe)
     }

boomerangScope-Opal/src/main/scala/boomerang/scope/opal/tac/OpalWrappedClass.scala

@@ -19,10 +19,10 @@ import boomerang.scope.Type
 import boomerang.scope.WrappedClass
 import java.util
 import java.util.Objects
-import org.opalj.br.ObjectType
+import org.opalj.br.ClassType
 import org.opalj.br.analyses.Project
 
-class OpalWrappedClass(val delegate: ObjectType, project: Project[_]) extends WrappedClass {
+class OpalWrappedClass(val delegate: ClassType, project: Project[_]) extends WrappedClass {
 
   override def getMethods: util.Set[Method] = {
     val classFile = project.classFile(delegate)

boomerangScope-Opal/src/test/scala/boomerang/scope/opal/OpalSetup.scala

@@ -33,7 +33,7 @@ class OpalSetup {
     OPALLogger.updateLogger(GlobalLogContext, DevNullLogger)
     project = Some(Project(new File(TargetClassPath.TARGET_CLASS_PATH)))
 
-    targetClass = project.get.classFile(ObjectType(targetClassName.replace(".", "/")))
+    targetClass = project.get.classFile(ClassType(targetClassName.replace(".", "/")))
   }
 
   def resolveMethod(methodSignature: MethodSignature): Method = {