Add static and default interface methods support

.gitignore

@@ -19,3 +19,4 @@ bin/
 .settings
 
 .classpath
+android-runtime.iml

test-app/app/build.gradle

@@ -195,6 +195,11 @@ android {
         }
     }
 
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_1_8
+        targetCompatibility JavaVersion.VERSION_1_8
+    }
+
     sourceSets.main {
         jniLibs.srcDir "$projectDir/libs/jni"
     }

test-app/app/src/main/assets/app/mainpage.js

@@ -20,6 +20,8 @@ shared.runRequireTests();
 shared.runWeakRefTests();
 shared.runRuntimeTests();
 shared.runWorkerTests();
+require("./tests/testInterfaceDefaultMethods");
+require("./tests/testInterfaceStaticMethods");
 require("./tests/testMetadata");
 require("./tests/testAsserts");
 require("./tests/testWeakRef");

test-app/app/src/main/assets/app/tests/testInterfaceDefaultMethods.js

@@ -0,0 +1,17 @@
+describe("Tests Java 8 default methods support", function () {
+
+    it("Test default method overrides in extending classes", function () {
+        var firstGen = new com.tns.tests.interfaces.defaultmethods.impl.FirstGeneration();
+        expect(firstGen.grow()).toBe("first generation grow");
+
+        var secondGeneration = new com.tns.tests.interfaces.defaultmethods.impl.SecondGeneration();
+        expect(secondGeneration.grow()).toBe("second generation grow");
+    })
+
+    it("Test default method overrides in interfaces chain", function () {
+        var producer = new com.tns.tests.interfaces.defaultmethods.impl.CarProducerImpl();
+        expect(producer.produce()).toBe("default produce in CarProducer");
+    })
+
+
+})

test-app/app/src/main/assets/app/tests/testInterfaceStaticMethods.js

@@ -0,0 +1,9 @@
+describe("Tests Java 8 static methods support", function () {
+
+    it("Test static method in interface", function () {
+        var producer = com.tns.tests.interfaces.staticmethods.StaticProducer;
+        expect(producer.staticProduce()).toBe("static produce");
+    })
+
+
+})

test-app/app/src/main/java/com/tns/tests/interfaces/defaultmethods/contract/CarProducer.java

@@ -0,0 +1,10 @@
+package com.tns.tests.interfaces.defaultmethods.contract;
+
+public interface CarProducer extends Producer{
+
+    @Override
+    default String produce(){
+        return "default produce in CarProducer";
+    }
+}
+

test-app/app/src/main/java/com/tns/tests/interfaces/defaultmethods/contract/Generation.java

@@ -0,0 +1,7 @@
+package com.tns.tests.interfaces.defaultmethods.contract;
+
+public interface Generation{
+    default String grow(){
+        return "default grow";
+    }
+}

test-app/app/src/main/java/com/tns/tests/interfaces/defaultmethods/contract/Producer.java

@@ -0,0 +1,9 @@
+package com.tns.tests.interfaces.defaultmethods.contract;
+
+public interface Producer{
+
+    default String produce(){
+        return "default produce in Producer";
+    }
+}
+

test-app/app/src/main/java/com/tns/tests/interfaces/defaultmethods/impl/CarProducerImpl.java

@@ -0,0 +1,7 @@
+package com.tns.tests.interfaces.defaultmethods.impl;
+
+import com.tns.tests.interfaces.defaultmethods.contract.CarProducer;
+
+public class CarProducerImpl implements CarProducer {
+
+}

test-app/app/src/main/java/com/tns/tests/interfaces/defaultmethods/impl/FirstGeneration.java

@@ -0,0 +1,12 @@
+package com.tns.tests.interfaces.defaultmethods.impl;
+
+import com.tns.tests.interfaces.defaultmethods.contract.Generation;
+
+public class FirstGeneration implements Generation {
+
+    @Override
+    public String grow(){
+        return "first generation grow";
+    }
+
+}

test-app/app/src/main/java/com/tns/tests/interfaces/defaultmethods/impl/SecondGeneration.java

@@ -0,0 +1,10 @@
+package com.tns.tests.interfaces.defaultmethods.impl;
+
+public class SecondGeneration extends FirstGeneration{
+
+    @Override
+    public String grow(){
+        return "second generation grow";
+    }
+
+}

test-app/app/src/main/java/com/tns/tests/interfaces/staticmethods/StaticProducer.java

@@ -0,0 +1,7 @@
+package com.tns.tests.interfaces.staticmethods;
+
+public interface StaticProducer {
+    static String staticProduce(){
+        return "static produce";
+    }
+}

test-app/build-tools/android-metadata-generator/src/src/com/telerik/metadata/Builder.java

@@ -1,12 +1,18 @@
 package com.telerik.metadata;
 
 import java.io.File;
+import java.lang.reflect.Array;
+import java.lang.reflect.Method;
+import java.net.URL;
+import java.net.URLClassLoader;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Comparator;
 import java.util.HashMap;
+import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
 
 import com.telerik.metadata.TreeNode.FieldInfo;
 import com.telerik.metadata.TreeNode.MethodInfo;
@@ -17,6 +23,7 @@
 import com.telerik.metadata.desc.MethodDescriptor;
 import com.telerik.metadata.desc.TypeDescriptor;
 import com.telerik.metadata.dx.DexFile;
+import com.telerik.metadata.parsing.ClassParser;
 
 public class Builder {
     private static class MethodNameComparator implements Comparator<MethodDescriptor> {
@@ -124,7 +131,9 @@ private static void setNodeMembers(ClassDescriptor clazz, TreeNode node, TreeNod
         }
 
         MethodDescriptor[] allMethods = ClassUtil.getAllMethods(clazz);
-        MethodDescriptor[] methods = clazz.getMethods();
+        MethodDescriptor[] classImplementedMethods = clazz.getMethods();
+        MethodDescriptor[] interfaceImplementedMethods = clazz.isClass() ? getDefaultMethodsFromImplementedInterfaces(clazz, classImplementedMethods) : new MethodDescriptor[0];
+        MethodDescriptor[] methods = concatenate(classImplementedMethods, interfaceImplementedMethods);
 
         Arrays.sort(methods, methodNameComparator);
 
@@ -151,8 +160,8 @@ private static void setNodeMembers(ClassDescriptor clazz, TreeNode node, TreeNod
                             && (m1.isPublic() || m1.isProtected())
                             && (isStatic == m1IsStatic)
                             && (m1.getName().equals(mi.name) && (m1
-                                    .getArgumentTypes().length == m
-                                    .getArgumentTypes().length))) {
+                            .getArgumentTypes().length == m
+                            .getArgumentTypes().length))) {
                         if (++countUnique > 1) {
                             break;
                         }
@@ -162,7 +171,7 @@ private static void setNodeMembers(ClassDescriptor clazz, TreeNode node, TreeNod
 
                 TypeDescriptor[] params = m.getArgumentTypes();
                 mi.signature = getMethodSignature(root, m.getReturnType(),
-                                                  params);
+                        params);
 
                 if (mi.signature != null) {
                     if (isStatic) {
@@ -195,7 +204,7 @@ private static void setFieldInfo(ClassDescriptor clazz, TreeNode node, TreeNode
                 TypeDescriptor t = f.getType();
                 boolean isPrimitive = ClassUtil.isPrimitive(t);
 
-                fi.valueType = isPrimitive ? TreeNode.getPrimitive(t): getOrCreateNode(root, t);
+                fi.valueType = isPrimitive ? TreeNode.getPrimitive(t) : getOrCreateNode(root, t);
                 fi.isFinalType = f.isFinal();
 
                 if (f.isStatic()) {
@@ -242,8 +251,19 @@ private static void getFieldsFromImplementedInterfaces(ClassDescriptor clazz, Tr
         }
     }
 
+    private static MethodDescriptor[] getDefaultMethodsFromImplementedInterfaces(ClassDescriptor clazz, MethodDescriptor[] originalClassMethodDescriptors) {
+        ClassParser parser = ClassParser.forClassDescriptor(clazz);
+
+        Set<MethodDescriptor> defaultMethods = parser.getAllDefaultMethodsFromImplementedInterfaces();
+        Set<MethodDescriptor> classMethods = new HashSet<MethodDescriptor>(Arrays.asList(originalClassMethodDescriptors));
+
+        defaultMethods.removeAll(classMethods);
+
+        return defaultMethods.toArray(new MethodDescriptor[0]);
+    }
+
     private static TreeNode getOrCreateNode(TreeNode root, TypeDescriptor type)
-    throws Exception {
+            throws Exception {
         TreeNode node;
 
         String typeName = type.getSignature();
@@ -272,7 +292,7 @@ private static TreeNode getOrCreateNode(TreeNode root, ClassDescriptor clazz, St
 
         if (ClassUtil.isArray(clazz)) {
             throw new UnsupportedOperationException("unexpected class="
-                                                    + clazz.getClassName());
+                    + clazz.getClassName());
         }
 
         TreeNode node = root;
@@ -307,7 +327,7 @@ private static TreeNode getOrCreateNode(TreeNode root, ClassDescriptor clazz, St
                 if (child == null) {
                     child = node.createChild(outerClassname);
                     child.nodeType = outer.isInterface() ? TreeNode.Interface
-                                     : TreeNode.Class;
+                            : TreeNode.Class;
                     if (outer.isStatic()) {
                         child.nodeType |= TreeNode.Static;
                     }
@@ -324,7 +344,7 @@ private static TreeNode getOrCreateNode(TreeNode root, ClassDescriptor clazz, St
                 child.nodeType = tmp.nodeType;
             } else {
                 child.nodeType = clazz.isInterface() ? TreeNode.Interface
-                                 : TreeNode.Class;
+                        : TreeNode.Class;
                 if (clazz.isStatic()) {
                     child.nodeType |= TreeNode.Static;
                 }
@@ -337,8 +357,8 @@ private static TreeNode getOrCreateNode(TreeNode root, ClassDescriptor clazz, St
                 baseClass = ClassUtil.getClassByName(predefinedSuperClassname);
             } else {
                 baseClass = clazz.isInterface()
-                            ? ClassUtil.getClassByName("java.lang.Object")
-                            : ClassUtil.getSuperclass(clazz);
+                        ? ClassUtil.getClassByName("java.lang.Object")
+                        : ClassUtil.getSuperclass(clazz);
             }
             if (baseClass != null) {
                 node.baseClassNode = getOrCreateNode(root, baseClass, null);
@@ -358,7 +378,7 @@ private static void copyBasePublicApi(ClassDescriptor baseClass, TreeNode node,
     }
 
     private static TreeNode createArrayNode(TreeNode root, String className)
-    throws Exception {
+            throws Exception {
         TreeNode currentNode = root;
         String currentClassname = className;
 
@@ -385,7 +405,7 @@ private static TreeNode createArrayNode(TreeNode root, String className)
             } else {
                 ClassDescriptor clazz = ClassRepo.findClass(name);
                 child.nodeType = clazz.isInterface() ? TreeNode.Interface
-                                 : TreeNode.Class;
+                        : TreeNode.Class;
                 if (clazz.isStatic()) {
                     child.nodeType |= TreeNode.Static;
                 }
@@ -397,22 +417,22 @@ private static TreeNode createArrayNode(TreeNode root, String className)
     }
 
     private static ArrayList<TreeNode> getMethodSignature(TreeNode root,
-            TypeDescriptor retType, TypeDescriptor[] params) throws Exception {
+                                                          TypeDescriptor retType, TypeDescriptor[] params) throws Exception {
         ArrayList<TreeNode> sig = new ArrayList<TreeNode>();
         boolean isVoid = retType.equals(TypeDescriptor.VOID);
 
         TreeNode node = null;
         if (!isVoid) {
             boolean isPrimitive = ClassUtil.isPrimitive(retType);
             node = isPrimitive ? TreeNode.getPrimitive(retType)
-                   : getOrCreateNode(root, retType);
+                    : getOrCreateNode(root, retType);
         }
         sig.add(node);
 
         for (TypeDescriptor param : params) {
             boolean isPrimitive = ClassUtil.isPrimitive(param);
             node = isPrimitive ? TreeNode.getPrimitive(param)
-                   : getOrCreateNode(root, param);
+                    : getOrCreateNode(root, param);
             if (node == null) {
                 return null;
             }
@@ -421,4 +441,16 @@ private static ArrayList<TreeNode> getMethodSignature(TreeNode root,
 
         return sig;
     }
+
+    private static <T> T[] concatenate(T[] a, T[] b) {
+        int aLen = a.length;
+        int bLen = b.length;
+
+        @SuppressWarnings("unchecked")
+        T[] c = (T[]) Array.newInstance(a.getClass().getComponentType(), aLen + bLen);
+        System.arraycopy(a, 0, c, 0, aLen);
+        System.arraycopy(b, 0, c, aLen, bLen);
+
+        return c;
+    }
 }

test-app/build-tools/android-metadata-generator/src/src/com/telerik/metadata/bcl/MethodInfo.java

@@ -33,6 +33,11 @@ public boolean isStatic() {
         return m.isStatic();
     }
 
+    @Override
+    public boolean isAbstract() {
+        return m.isAbstract();
+    }
+
     @Override
     public String getName() {
         return m.getName();
@@ -62,4 +67,19 @@ public TypeDescriptor getReturnType() {
     public MetadataInfoAnnotationDescriptor getMetadataInfoAnnotation() {
         return null;
     }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+
+        MethodInfo that = (MethodInfo) o;
+
+        return m.equals(that.m);
+    }
+
+    @Override
+    public int hashCode() {
+        return m.hashCode();
+    }
 }

test-app/build-tools/android-metadata-generator/src/src/com/telerik/metadata/desc/MethodDescriptor.java

@@ -5,6 +5,7 @@ public interface MethodDescriptor {
     boolean isProtected();
     boolean isSynthetic();
     boolean isStatic();
+    boolean isAbstract();
 
     String getName();
     String getSignature();