public boolean isArrayType() { return getType().isArrayClass(); }
public boolean isArrayType() { return getType().isArrayClass(); }
public boolean isArrayType() { return getType().isArrayClass(); }
public boolean isArrayType() { return getType().isArrayClass(); }
/** * Collects all implemented interfaces for a given class * @param clazz the IClass object to analyze * @return a set of IClass objects representing the interfaces */ public static Set<IClass> collectAllInterfaces(IClass clazz) { // do not check array classes if (clazz.isArrayClass()) return new HashSet<IClass>(); Set<IClass> interfaces = new HashSet<IClass>(clazz.getDirectInterfaces()); for (IClass c : clazz.getDirectInterfaces()) interfaces.addAll(collectAllInterfaces(c)); return interfaces; }
/** * TODO: expand this API to differentiate between different array indices * * @param I an InstanceKey representing an abstract array * @return the PointerKey that acts as a representation for the class of pointers that includes the given array contents, or null * if none found. * @throws IllegalArgumentException if I is null */ public PointerKey getPointerKeyForArrayContents(InstanceKey I) { if (I == null) { throw new IllegalArgumentException("I is null"); } IClass C = I.getConcreteType(); if (!C.isArrayClass()) { assert false : "illegal arguments: " + I; } return pointerKeyFactory.getPointerKeyForArrayContents(I); }
/** * TODO: expand this API to differentiate between different array indices * * @param I an InstanceKey representing an abstract array * @return the PointerKey that acts as a representation for the class of pointers that includes the given array contents, or null * if none found. * @throws IllegalArgumentException if I is null */ public PointerKey getPointerKeyForArrayContents(InstanceKey I) { if (I == null) { throw new IllegalArgumentException("I is null"); } IClass C = I.getConcreteType(); if (!C.isArrayClass()) { assert false : "illegal arguments: " + I; } return pointerKeyFactory.getPointerKeyForArrayContents(I); }
/** * @return the number of classes that immediately extend klass. if klass is an array class A[][]...[], we return number of * immediate subclasses of A. If A is primitive, we return 0. */ @Override public int getNumberOfImmediateSubclasses(IClass klass) { if (klass.isArrayClass()) { IClass innermost = getInnermostTypeOfArrayClass(klass); return innermost == null ? 0 : getNumberOfImmediateSubclasses(innermost); } Node node = findNode(klass); return node.children.size(); }
/** * @return the number of classes that immediately extend klass. if klass is an array class A[][]...[], we return number of * immediate subclasses of A. If A is primitive, we return 0. */ @Override public int getNumberOfImmediateSubclasses(IClass klass) { if (klass.isArrayClass()) { IClass innermost = getInnermostTypeOfArrayClass(klass); return innermost == null ? 0 : getNumberOfImmediateSubclasses(innermost); } Node node = findNode(klass); return node.children.size(); }
/** * @return the classes that immediately extend klass. if klass is an array class A[][]...[], we return array classes B[][]...[] * (same dimensionality) where B is an immediate subclass of A. If A is primitive, we return the empty set. */ @Override public Collection<IClass> getImmediateSubclasses(IClass klass) { if (klass.isArrayClass()) { return getImmediateArraySubclasses((ArrayClass)klass); } Function<Node, IClass> node2Class = n -> n.klass; return Iterator2Collection.toSet(new MapIterator<>(findNode(klass).children.iterator(), node2Class)); }
/** * @return the classes that immediately extend klass. if klass is an array class A[][]...[], we return array classes B[][]...[] * (same dimensionality) where B is an immediate subclass of A. If A is primitive, we return the empty set. */ @Override public Collection<IClass> getImmediateSubclasses(IClass klass) { if (klass.isArrayClass()) { return getImmediateArraySubclasses((ArrayClass)klass); } Function<Node, IClass> node2Class = n -> n.klass; return Iterator2Collection.toSet(new MapIterator<>(findNode(klass).children.iterator(), node2Class)); }
/** * Return set of all subclasses of type in the Class Hierarchy TODO: Tune this implementation. Consider caching if necessary. * * @return Set of IClasses */ private Set<IClass> computeSubClassesInternal(IClass T) { if (T.isArrayClass()) { return Collections.singleton(T); } Node node = findNode(T); assert node != null : "null node for class " + T; HashSet<IClass> result = HashSetFactory.make(3); result.add(T); for (Node child : Iterator2Iterable.make(node.getChildren())) { result.addAll(computeSubClasses(child.klass.getReference())); } return result; }
/** * Return set of all subclasses of type in the Class Hierarchy TODO: Tune this implementation. Consider caching if necessary. * * @return Set of IClasses */ private Set<IClass> computeSubClassesInternal(IClass T) { if (T.isArrayClass()) { return Collections.singleton(T); } Node node = findNode(T); assert node != null : "null node for class " + T; HashSet<IClass> result = HashSetFactory.make(3); result.add(T); for (Node child : Iterator2Iterable.make(node.getChildren())) { result.addAll(computeSubClasses(child.klass.getReference())); } return result; }
@Override public TypeAbstraction meet(TypeAbstraction rhs) { if (rhs == TOP) { return this; } else if (rhs instanceof ConeType) { ConeType other = (ConeType) rhs; if (type.equals(other.type)) { return this; } else if (type.isArrayClass() || other.type.isArrayClass()) { // give up on arrays. We don't care anyway. return new ConeType(type.getClassHierarchy().getRootClass()); } else { return new ConeType(type.getClassHierarchy().getLeastCommonSuperclass(this.type, other.type)); } } else if (rhs instanceof PointType) { return rhs.meet(this); } else if (rhs instanceof PrimitiveType) { return TOP; } else { Assertions.UNREACHABLE("unexpected type " + rhs.getClass()); return null; } }
@Override public TypeAbstraction meet(TypeAbstraction rhs) { if (rhs == TOP) { return this; } else if (rhs instanceof ConeType) { ConeType other = (ConeType) rhs; if (type.equals(other.type)) { return this; } else if (type.isArrayClass() || other.type.isArrayClass()) { // give up on arrays. We don't care anyway. return new ConeType(type.getClassHierarchy().getRootClass()); } else { return new ConeType(type.getClassHierarchy().getLeastCommonSuperclass(this.type, other.type)); } } else if (rhs instanceof PointType) { return rhs.meet(this); } else if (rhs instanceof PrimitiveType) { return TOP; } else { Assertions.UNREACHABLE("unexpected type " + rhs.getClass()); return null; } }
private Map<PointerKey, Object> computePointerKeys(IClass klass) { Map<PointerKey, Object> result = HashMapFactory.make(); if (klass.isArrayClass()) { ArrayClass a = (ArrayClass) klass; if (a.getElementClass() != null && a.getElementClass().isReferenceType()) { PointerKey p = pointerKeys.getPointerKeyForArrayContents(new ConcreteTypeKey(a)); result.put(p, p); } } else { for (IField f : klass.getAllFields()) { if (!f.getFieldTypeReference().isPrimitiveType()) { if (f.isStatic()) { PointerKey p = pointerKeys.getPointerKeyForStaticField(f); result.put(p, p); } else { PointerKey p = pointerKeys.getPointerKeyForInstanceField(new ConcreteTypeKey(klass), f); result.put(p, p); } } } } return result; }
/** * Record that we have a new instanceKey for a given declared type. */ private void registerInstanceOfClass(IClass klass, int index) { if (DEBUG) { System.err.println("registerInstanceOfClass " + klass + ' ' + index); } assert !klass.getReference().equals(TypeReference.JavaLangObject); IClass T = klass; registerInstanceWithAllSuperclasses(index, T); registerInstanceWithAllInterfaces(klass, index); if (klass.isArrayClass()) { ArrayClass aClass = (ArrayClass) klass; int dim = aClass.getDimensionality(); registerMultiDimArraysForArrayOfObjectTypes(dim, index, aClass); IClass elementClass = aClass.getInnermostElementClass(); if (elementClass != null) { registerArrayInstanceWithAllSuperclassesOfElement(index, elementClass, dim); registerArrayInstanceWithAllInterfacesOfElement(index, elementClass, dim); } } }
/** * Record that we have a new instanceKey for a given declared type. */ private void registerInstanceOfClass(IClass klass, int index) { if (DEBUG) { System.err.println("registerInstanceOfClass " + klass + ' ' + index); } assert !klass.getReference().equals(TypeReference.JavaLangObject); IClass T = klass; registerInstanceWithAllSuperclasses(index, T); registerInstanceWithAllInterfaces(klass, index); if (klass.isArrayClass()) { ArrayClass aClass = (ArrayClass) klass; int dim = aClass.getDimensionality(); registerMultiDimArraysForArrayOfObjectTypes(dim, index, aClass); IClass elementClass = aClass.getInnermostElementClass(); if (elementClass != null) { registerArrayInstanceWithAllSuperclassesOfElement(index, elementClass, dim); registerArrayInstanceWithAllInterfacesOfElement(index, elementClass, dim); } } }
private boolean allFieldsArePrimitive(IClass c) { if (c.isArrayClass()) { TypeReference t = c.getReference().getArrayElementType(); return t.isPrimitiveType(); } else { if (c.getReference().equals(TypeReference.JavaLangObject)) { return true; } else { for (IField f : c.getDeclaredInstanceFields()) { if (f.getReference().getFieldType().isReferenceType()) { return false; } } return allFieldsArePrimitive(c.getSuperclass()); } } }
private boolean allFieldsArePrimitive(IClass c) { if (c.isArrayClass()) { TypeReference t = c.getReference().getArrayElementType(); return t.isPrimitiveType(); } else { if (c.getReference().equals(TypeReference.JavaLangObject)) { return true; } else { for (IField f : c.getDeclaredInstanceFields()) { if (f.getReference().getFieldType().isReferenceType()) { return false; } } return allFieldsArePrimitive(c.getSuperclass()); } } }