ObjectType -> ClassType

Author: Dominik Helm

artifacts/DeadMethods_JDK7u80/caseStudyCPA.html

@@ -231,7 +231,7 @@ <h3 id="adding-line-numbers">Adding Line Numbers</h3>
 ).toDA()
 </code></pre>
 <h3 id="adding-further-attributes">Adding Further attributes</h3>
-<p>The DSL interacts seamlessly with the bytecode representation and all attibutes can always be added to the attributes as expected. For example, the following class file is marked as being <code>Synthetic</code> and the origin is set using <code>SourceFile(&quot;...&quot;)</code>. The method is marked as being <code>Deprecated</code> and as throwing the exceptions <code>java.lang.Exception</code>. In the last case, we use the DSL's <code>EXCEPTIONS</code> table builder. It enables us to just specify the names of the exceptions. Alternatively, it would have been possible to directly create the underlying <code>br.ExceptionsTable</code> using <code>ObjectType</code>s.</p>
+<p>The DSL interacts seamlessly with the bytecode representation and all attibutes can always be added to the attributes as expected. For example, the following class file is marked as being <code>Synthetic</code> and the origin is set using <code>SourceFile(&quot;...&quot;)</code>. The method is marked as being <code>Deprecated</code> and as throwing the exceptions <code>java.lang.Exception</code>. In the last case, we use the DSL's <code>EXCEPTIONS</code> table builder. It enables us to just specify the names of the exceptions. Alternatively, it would have been possible to directly create the underlying <code>br.ExceptionsTable</code> using <code>ClassType</code>s.</p>
 <pre><code>val cb = CLASS(
     accessModifiers = PUBLIC SUPER,
     thisType = &quot;SimpleMethodClass&quot;,

artifacts/DeadMethods_JDK7u80/caseStudyNaive.html

@@ -89,11 +89,11 @@ <h1 id="querying-the-class-hierarchy">Querying the Class Hierarchy</h1>
 val classHierarchy = p.classHierarchy
 </code></pre>
 <p>The class hierarchy, e.g., directly makes the information about a type's super/sub types available:</p>
-<pre><code>def subtypeInformation(ObjectType) : SubtypeInformation 
-def supertypeInformation(ObjectType) : SupertypeInformation 
+<pre><code>def subtypeInformation(ClassType) : SubtypeInformation 
+def supertypeInformation(ClassType) : SupertypeInformation 
 </code></pre>
 <p>To get, e.g., all subtypes of <code>java.io.Serializable</code>, it is sufficient to query the subtypes information:</p>
-<pre><code>val subtypesOfSerializable = classHierarchy.subtypeInformation(ObjectType(&quot;java/io/Serializable&quot;))
+<pre><code>val subtypesOfSerializable = classHierarchy.subtypeInformation(ClassType(&quot;java/io/Serializable&quot;))
 </code></pre>
 <blockquote>
 <p>Recall that in Java bytecode package names are separated using &quot;/&quot; and not &quot;.&quot; as used in Java/Scala/... source code.</p>
@@ -102,7 +102,7 @@ <h1 id="querying-the-class-hierarchy">Querying the Class Hierarchy</h1>
 <p>OPAL's class hierarchy supports partial class hierarchies and - in case that a class hierarchy is incomplete – generally follows a best-effort approach to determine sub-/supertype relations. In particular, when <code>isSubtypeOf</code> is used, <code>java.lang.Object</code> will always be treated as the supertype and an <strong>interface</strong> will never be the subtype of a class type, even if the supertype hierarchy for the interface is incomplete. As a matter of fact, the standard JDK/rt.jar contains references to classes that are not delivered as part of the JDK and therefore the class hierarchy is basically always incomplete.</p>
 </blockquote>
 <p>If you don't know whether a given type is known to the class hierarchy, you should call the <code>get</code> method to avoid potential <code>NoSuchElementExceptions</code>.</p>
-<pre><code>classHierarchy.subtypeInformation.get(ObjectType(&quot;java/io/Serializable&quot;)).foreach{subtypeInformation =&gt; ... }
+<pre><code>classHierarchy.subtypeInformation.get(ClassType(&quot;java/io/Serializable&quot;)).foreach{subtypeInformation =&gt; ... }
 </code></pre>
 
                     </div>

artifacts/DeadMethods_JDK7u80/caseStudyOPA.html

@@ -104,7 +104,7 @@ <h3 id="using-the-3-address-code">Using the 3-Address Code</h3>
 <pre><code>val tac = p.get(ComputeACAIKey)
 </code></pre>
 <p><em>Step 3</em> - To get the TAC of a specific method with a body just look it up:</p>
-<pre><code>val cf = p.classFile(ObjectType(&quot;ai/domain/IntegerValuesFrenzy&quot;)).get
+<pre><code>val cf = p.classFile(ClassType(&quot;ai/domain/IntegerValuesFrenzy&quot;)).get
 val m = cf.findMethod(&quot;someSwitch&quot;).head
 val taCode = tac(m)
 </code></pre>
@@ -201,7 +201,7 @@ <h2 id="examples">Examples</h2>
 <pre><code>import org.opalj._
 val p = br.analyses.Project(new java.io.File(&quot;OPAL/bi/target/scala-2.13/resource_managed/test/ai.jar&quot;))
 val tacAIKey = p.get(tac.ComputeTACAIKey)
-val code = tacAIKey(p.classFile(br.ObjectType(&quot;ai/MethodsWithTypeChecks&quot;)).get.findMethod(&quot;requiredCast&quot;).head)
+val code = tacAIKey(p.classFile(br.ClassType(&quot;ai/MethodsWithTypeChecks&quot;)).get.findMethod(&quot;requiredCast&quot;).head)
 </code></pre>
 <p>The 3-address code of the above method is shown next:</p>
 <pre><code>static java.io.FileNotFoundException requiredCast(java.lang.Cloneable){

examples/BytecodeEngineering.html

@@ -2,7 +2,7 @@ import java.net.URL
 
 import org.opalj.br.ClassFile
 import org.opalj.br.Field
-import org.opalj.br.ObjectType
+import org.opalj.br.ClassType
 import org.opalj.br.analyses.BasicReport
 import org.opalj.br.analyses.Project
 import org.opalj.br.analyses.ProjectAnalysisApplication
@@ -82,7 +82,7 @@ class ClassImmutabilityAnalysis(val project: SomeProject) extends FPCFAnalysis {
 
         val superclassType = classFile.superclassType
 
-        if (superclassType.isDefined && superclassType.get != ObjectType.Object) {
+        if (superclassType.isDefined && superclassType.get != ClassType.Object) {
             val superclass = project.classFile(superclassType.get)
             if (superclass.isEmpty)
                 return Result(classFile, MutableClass)
@@ -238,9 +238,9 @@ class FieldImmutabilityAnalysis(val project: SomeProject) extends FPCFAnalysis {
             if (field.isFinal) field.fieldType match {
                 case bt if bt.isBaseType =>
                     TransitivelyImmutableField
-                case wt: ObjectType if ObjectType.isPrimitiveTypeWrapper(wt) =>
+                case wt: ClassType if ClassType.isPrimitiveTypeWrapper(wt) =>
                     TransitivelyImmutableField
-                case st if st == ObjectType.String =>
+                case st if st == ClassType.String =>
                     TransitivelyImmutableField
                 case _ =>
                     NonTransitivelyImmutableField

examples/ClassHierarchy.html

@@ -88,12 +88,12 @@ <h1 id="collaborative-analyses">Collaborative Analyses</h1>
 <p>We will develop the implementation in small steps, but you can get the complete, runnable source code for this analysis <a href="InstantiatedTypesAnalysis.scala">here</a>.</p>
 <h2 id="defining-a-lattice">Defining a Lattice</h2>
 <p>As is always the case for fixed-point analyses in OPAL, we need a suitable lattice to represent our analysis' results.<br />
-In order to represent the set of all classes potentially instantiated, we thus create a lattice of set<sup title="OPAL's UIDSet is an optimized set for several kinds of entities in OPAL, including, e.g., ObjectType which represents the type of a class.">[note]</sup> values:</p>
+In order to represent the set of all classes potentially instantiated, we thus create a lattice of set<sup title="OPAL's UIDSet is an optimized set for several kinds of entities in OPAL, including, e.g., ClassType which represents the type of a class.">[note]</sup> values:</p>
 <pre><code class="language-scala">sealed trait InstantiatedTypesPropertyMetaInformation extends PropertyMetaInformation {
     final type Self = InstantiatedTypes
 }
 
-case class InstantiatedTypes(classes: UIDSet[ObjectType]) extends InstantiatedTypesPropertyMetaInformation with OrderedProperty {
+case class InstantiatedTypes(classes: UIDSet[ClassType]) extends InstantiatedTypesPropertyMetaInformation with OrderedProperty {
     override def checkIsEqualOrBetterThan(e: Entity, other: InstantiatedTypes): Unit = {
         if (!classes.subsetOf(other.classes)) {
             throw new IllegalArgumentException(s&quot;$e: illegal refinement of $other to $this&quot;)
@@ -113,7 +113,7 @@ <h2 id="defining-a-lattice">Defining a Lattice</h2>
     )
 }
 </code></pre>
-<p>We use a case class here to provide a container for an arbitrary set of <a href="/library/api/SNAPSHOT/org/opalj/br/ObjectType.html"><code>ObjectType</code></a>s.</p>
+<p>We use a case class here to provide a container for an arbitrary set of <a href="/library/api/SNAPSHOT/org/opalj/br/ClassType.html"><code>ClassType</code></a>s.</p>
 <p>Note that for the <code>key</code>, we didn't just provide a fallback value, but a small function that is called whenever <code>InstantiatedTypes</code> are needed, but have not been computed.<br />
 This is to distinguish between two cases:<br />
 Either, the analysis (which we will implement below) was executed, but there simply are no classes that have been instantiated.

examples/TAC.html

@@ -196,7 +196,7 @@ <h2 id="implementing-the-analysis">Implementing the Analysis</h2>
 
     val superclassType = classFile.superclassType
 
-    if(superclassType.isDefined &amp;&amp; superclassType.get != ObjectType.Object) {
+    if(superclassType.isDefined &amp;&amp; superclassType.get != ClassType.Object) {
         [...]
     }
 
@@ -205,9 +205,9 @@ <h2 id="implementing-the-analysis">Implementing the Analysis</h2>
 </code></pre>
 <p>First, we get the type of the superclass from our classfile.<br />
 Note that some classes, in particular <code>java.lang.Object</code>, do not have superclasses, in which case we can't (and don't have to) check any superclass' immutability.<br />
-We also don't have to check the immutability of <code>java.lang.Object</code> (represented by <code>ObjectType.Object</code>) as we know it is transitively immutable because it has no fields.<br />
+We also don't have to check the immutability of <code>java.lang.Object</code> (represented by <code>ClassType.Object</code>) as we know it is transitively immutable because it has no fields.<br />
 Checking whether the superclass is <code>java.lang.Object</code> not only allows us to skip checking the superclass, but also allows to get useful results even when the JDK is not part of our analyzed software and thus the classfile for <code>java.lang.Object</code> is not available.</p>
-<pre><code class="language-scala">    if(superclassType.isDefined &amp;&amp; superclassType.get != ObjectType.Object) {
+<pre><code class="language-scala">    if(superclassType.isDefined &amp;&amp; superclassType.get != ClassType.Object) {
         val superclass = project.classFile(superclassType.get)
         if(superclass.isEmpty)
             return Result(classFile, MutableClass)

tutorial/ClassImmutabilityAnalysis.scala

@@ -2,7 +2,7 @@ import java.net.URL
 
 import org.opalj.collection.immutable.UIDSet
 import org.opalj.br.DeclaredMethod
-import org.opalj.br.ObjectType
+import org.opalj.br.ClassType
 import org.opalj.br.analyses.BasicReport
 import org.opalj.br.analyses.Project
 import org.opalj.br.analyses.ProjectAnalysisApplication
@@ -44,7 +44,7 @@ sealed trait InstantiatedTypesPropertyMetaInformation extends PropertyMetaInform
     final type Self = InstantiatedTypes
 }
 
-case class InstantiatedTypes(classes: UIDSet[ObjectType]) extends InstantiatedTypesPropertyMetaInformation with OrderedProperty {
+case class InstantiatedTypes(classes: UIDSet[ClassType]) extends InstantiatedTypesPropertyMetaInformation with OrderedProperty {
     override def checkIsEqualOrBetterThan(e: Entity, other: InstantiatedTypes): Unit = {
         if (!classes.subsetOf(other.classes)) {
             throw new IllegalArgumentException(s"$e: illegal refinement of $other to $this")