refactor processing of interface/abstract methods

Author: Mihail Slavchev

android-static-binding-generator/project/staticbindinggenerator/src/main/java/org/nativescript/staticbindinggenerator/ClassInfo.java

@@ -164,6 +164,11 @@ public boolean isFinal() {
         return (isArray() || isPrimitive()) ? false : clazz.isFinal();
     }
 
+    @Override
+    public boolean isAbstract() {
+        return (isArray() || isPrimitive()) ? false : clazz.isAbstract();
+    }
+
     static ClassDescriptor fromPrimitive(ClassDescriptor primitiveType, int rank) {
         return (rank == 0) ? primitiveType : new ClassInfo(primitiveType, rank);
     }

android-static-binding-generator/project/staticbindinggenerator/src/main/java/org/nativescript/staticbindinggenerator/MethodInfo.java

@@ -71,6 +71,11 @@ public boolean isFinal() {
         return m.isFinal();
     }
 
+    @Override
+    public boolean isAbstract() {
+        return m.isAbstract();
+    }
+
     private ClassDescriptor convertType(Type t) {
         ClassDescriptor desc;
         String sig = t.getSignature();

binding-generator/src/main/java/com/tns/bindings/Dump.java

@@ -251,56 +251,56 @@ private String getMethodSignature(MethodDescriptor m)
 		return m.getName() + sig.substring(nameIdx, endSigIdx);
 	}
 
-	private void collectInterfaceMethods(ClassDescriptor clazz, HashSet<String> methodOverrides, List<MethodDescriptor> result) {
-		if (!clazz.isInterface()) {
+	private void collectAbstractMethods(final ClassDescriptor clazz, List<MethodDescriptor> result) {
+		if (!clazz.isAbstract()) {
 			return;
 		}
-		Set<String> objectMethods = new HashSet<String>();
+		Set<String> alreadyAddedMethods = new HashSet<String>();
+		for (MethodDescriptor md: result) {
+			String sig = getMethodSignature(md);
+			alreadyAddedMethods.add(sig);
+		}
+
+		Set<String> concreteMethods = new HashSet<String>();
         // TODO refactor this
-        ClassDescriptor objCD = new ClassInfo(Object.class);
-		for (MethodDescriptor objMethod: objCD.getDeclaredMethods())
-		{
-			if (!objMethod.isStatic())
-			{
+        ClassDescriptor startingConcreteClassDesc = clazz.isInterface() ? new ClassInfo(Object.class) : clazz;
+		for (MethodDescriptor objMethod: startingConcreteClassDesc.getDeclaredMethods()) {
+			if (!objMethod.isStatic()) {
 				String sig = getMethodSignature(objMethod);
-				objectMethods.add(sig);
+				concreteMethods.add(sig);
 			}
 		}
 
-		Deque<ClassDescriptor> extendedInterfaces = new ArrayDeque<ClassDescriptor>();
+		Deque<ClassDescriptor> typesToProcess = new ArrayDeque<ClassDescriptor>();
+		typesToProcess.add(startingConcreteClassDesc);
 		if (clazz.isInterface()) {
-			extendedInterfaces.add(clazz);
-		} else {
-			extendedInterfaces.addAll(Arrays.asList(clazz.getInterfaces()));
+			typesToProcess.add(clazz);
 		}
 
-		Set<MethodDescriptor> notImplementedObjectMethods = new HashSet<MethodDescriptor>();
-
-		while (!extendedInterfaces.isEmpty()) {
-			ClassDescriptor currentInterface = extendedInterfaces.pollFirst();
-			MethodDescriptor[] ifaceMethods = currentInterface.getDeclaredMethods();
-			for (MethodDescriptor ifaceMethod: ifaceMethods)
-			{
-				if (!ifaceMethod.isStatic())
-				{
-					String sig = getMethodSignature(ifaceMethod);
-					if (objectMethods.contains(sig) && !methodOverrides.contains(ifaceMethod.getName()))
-					{
-						notImplementedObjectMethods.add(ifaceMethod);
+		while (!typesToProcess.isEmpty()) {
+			ClassDescriptor currentType = typesToProcess.pollFirst();
+			MethodDescriptor[] methods = currentType.getDeclaredMethods();
+			for (MethodDescriptor m: methods) {
+				if (m.isStatic()) {
+					continue;
+				}
+				String sig = getMethodSignature(m);
+				if (m.isAbstract()) {
+					if (!concreteMethods.contains(sig) && !alreadyAddedMethods.contains(sig)) {
+						result.add(m);
+						alreadyAddedMethods.add(sig);
 					}
+				} else if (!concreteMethods.contains(sig)) {
+					concreteMethods.add(sig);
 				}
 			}
 
-			for (MethodDescriptor ifaceMethod: ifaceMethods)
-			{
-				if (!notImplementedObjectMethods.contains(ifaceMethod))
-				{
-					result.add(ifaceMethod);
-				}
+			if (!currentType.isInterface() && !currentType.getName().equals("java.lang.Object")) {
+				typesToProcess.addFirst(currentType.getSuperclass());
 			}
 
-			for (ClassDescriptor iface: currentInterface.getInterfaces()) {
-				extendedInterfaces.add(iface);
+			for (ClassDescriptor iface: currentType.getInterfaces()) {
+				typesToProcess.add(iface);
 			}
 		}
 	}
@@ -309,11 +309,10 @@ private MethodDescriptor[] getSupportedMethods(ClassDescriptor clazz, HashSet<St
 	{
 		ArrayList<MethodDescriptor> result = new ArrayList<MethodDescriptor>();
 
-		collectInterfaceMethods(clazz, methodOverrides, result);
+		collectAbstractMethods(clazz, result);
 
-		for (ClassDescriptor iface : interfacesToImplement)
-		{
-			collectInterfaceMethods(iface, methodOverrides, result);
+		for (ClassDescriptor iface : interfacesToImplement) {
+			collectAbstractMethods(iface, result);
 		}
 
 		if (!clazz.isInterface())

binding-generator/src/main/java/com/tns/bindings/desc/ClassDescriptor.java

@@ -88,6 +88,11 @@ public boolean isFinal() {
             return false;
         }
 
+        @Override
+        public boolean isAbstract() {
+            return false;
+        }
+
         public static String getBoxedTypeName(ClassDescriptor c) {
             String name = null;
             if (c.isPrimitive()) {

binding-generator/src/main/java/com/tns/bindings/desc/Descriptor.java

@@ -12,4 +12,6 @@ public interface Descriptor {
     boolean isProtected();
 
     boolean isFinal();
+
+    boolean isAbstract();
 }

binding-generator/src/main/java/com/tns/bindings/desc/reflection/ClassInfo.java

@@ -140,4 +140,9 @@ public boolean isProtected() {
     public boolean isFinal() {
         return Modifier.isFinal(clazz.getModifiers());
     }
+
+    @Override
+    public boolean isAbstract() {
+        return Modifier.isAbstract(clazz.getModifiers());
+    }
 }

binding-generator/src/main/java/com/tns/bindings/desc/reflection/MethodInfo.java

@@ -14,6 +14,7 @@ public class MethodInfo implements MethodDescriptor {
     private final boolean m_isPublic;
     private final boolean m_isProtected;
     private final boolean m_isFinal;
+    private final boolean m_isAbstract;
     private Class<?>[] m_parameterTypes;
     private Class<?> m_retType;
     private String m_name;
@@ -43,6 +44,7 @@ private MethodInfo(int modifiers) {
         m_isPublic = Modifier.isPublic(modifiers);
         m_isProtected = Modifier.isProtected(modifiers);
         m_isFinal = Modifier.isFinal(modifiers);
+        m_isAbstract = Modifier.isAbstract(modifiers);
     }
 
     @Override
@@ -98,4 +100,9 @@ public boolean isProtected() {
     public boolean isFinal() {
         return m_isFinal;
     }
+
+    @Override
+    public boolean isAbstract() {
+        return m_isAbstract;
+    }
 }