add support of varargs

processor/src/main/java/org/bsc/processor/TypescriptHelper.java

@@ -5,6 +5,7 @@
 import java.beans.BeanInfo;
 import java.beans.IntrospectionException;
 import java.beans.PropertyDescriptor;
+import java.lang.reflect.Array;
 import java.lang.reflect.GenericArrayType;
 import java.lang.reflect.Method;
 import java.lang.reflect.Modifier;
@@ -386,6 +387,7 @@ else if( type instanceof WildcardType ) {
 		}
 		else if( type instanceof GenericArrayType ) {
 			final GenericArrayType t = (GenericArrayType)type;
+
 			log( "generic array type: %s",  t.getGenericComponentType().getTypeName() );	
 			//throw new IllegalArgumentException( format("type <%s> 'GenericArrayType' is a  not supported yet!", type));	
 
@@ -425,7 +427,10 @@ private static String convertJavaToTS(	Class<?> type,
         if( char[].class.equals(type) ) return "chararray";
         if( byte[].class.equals(type) ) return "bytearray";
 
-        if( type.isArray()) return format("[any] /* %s */",type.getName());
+        if( type.isArray()) {
+        		//return format("[any] /* %s */",type.getName());        		
+        		return format( "[%s]", convertJavaToTS(type.getComponentType(), declaringClass, declaredClassMap,packageResolution));
+        }
 
         if( declaredClassMap.containsKey(type.getName()) ) {
         		return getTypeName(type, declaringClass, packageResolution);

processor/src/main/java/org/bsc/processor/TypescriptProcessor.java

@@ -2,19 +2,16 @@
 
 import static org.bsc.processor.TypescriptHelper.convertJavaToTS;
 import static org.bsc.processor.TypescriptHelper.getClassDecl;
-import static org.bsc.processor.TypescriptHelper.getTypeName;
+import static org.bsc.processor.TypescriptHelper.getParameterName;
 import static org.bsc.processor.TypescriptHelper.getSimpleName;
 import static org.bsc.processor.TypescriptHelper.isStaticMethod;
-import static org.bsc.processor.TypescriptHelper.getParameterName;
 
-import java.beans.PropertyDescriptor;
 import java.io.Closeable;
 import java.io.IOException;
 import java.io.Serializable;
 import java.lang.reflect.Method;
 import java.lang.reflect.Modifier;
 import java.lang.reflect.Parameter;
-import java.lang.reflect.ParameterizedType;
 import java.lang.reflect.Type;
 import java.lang.reflect.TypeVariable;
 import java.nio.file.Path;
@@ -163,87 +160,34 @@ public boolean process( Context processingContext ) throws Exception {
 
         return true;
     }
-
-    /**
-     *
-     * @param declaringClass
-     * @param pd
-     * @param declaredClassMap
-     * @return
-     */
-    private String getPropertyDecl(	Class<?> declaringClass, 
-    									PropertyDescriptor pd, 
-    									java.util.Map<String, Class<?>> declaredClassMap ) {
-
-	    final StringBuilder sb = new StringBuilder();
-
-	    sb.append(pd.getName());
-	    if( declaringClass.isInterface()) sb.append('?');
-
-	    sb.append(':');
-
-	    final Method getter = pd.getReadMethod();
-
-	    if( getter != null ) {
-
-			final Type rType = getter.getGenericReturnType();
-			if( rType instanceof ParameterizedType ) {
-
-				final Type pClass =  ((ParameterizedType)rType).getActualTypeArguments()[0];
-
-				final String typeName = pClass.getTypeName();
-
-				try {
-					final String name = getTypeName( pClass, pd.getPropertyType(), true);
-
-					final String r = rType.getTypeName()
-							.replaceAll(typeName, name)
-							.replaceAll("<[\\w\\?]>", "<any>")
-							;
-
-					info( "getPropertyDecl: [%s] [%s] [%s] [%s]", pd.getName(), typeName, rType.getTypeName(), r);
-
-					return sb.append( r ).toString();
-
-				} catch (ClassNotFoundException e) {
-
-					warn( "getPropertyDecl: type [%s] not found!", typeName);
-
-				}
-
-	    		}
-
-	    }
-
-	    final String tsType = convertJavaToTS( pd.getPropertyType(),
-                                                declaringClass,
-                                                declaredClassMap,
-                                                true);
-
-        return sb.append(tsType)
-                 .toString();
-	}
-
     /**
      * 
      * @param m
      * @param declaringClass
      * @param declaredClassMap
      * @return
      */
-    protected String getMethodParametersDecl(	Method m, 
-    												Class<?> declaringClass, 
-    												java.util.Map<String, Class<?>> declaredClassMap,
-    												boolean packageResolution ) 
+    protected String getMethodParametersAndReturnDecl(	Method m, 
+    											Class<?> declaringClass, 
+    											java.util.Map<String, Class<?>> declaredClassMap,
+    											boolean packageResolution ) 
     {
         final Parameter[] params = m.getParameters();
 
         final String params_string =
         		Arrays.stream(params)
-        				.map( (tp) ->
-        					String.format( "%s:%s",
-        						getParameterName(tp),
-        						convertJavaToTS(tp.getParameterizedType(),declaringClass,declaredClassMap, packageResolution) ) )
+        				.map( (tp) -> {
+
+        					final String name = getParameterName(tp);
+
+
+        					if( tp.isVarArgs() ) {
+            					final String type = convertJavaToTS(tp.getType().getComponentType(),declaringClass,declaredClassMap, packageResolution) ;
+        						return String.format( "...%s:%s[]", name, type );
+        					}
+        					final String type = convertJavaToTS(tp.getParameterizedType(),declaringClass,declaredClassMap, packageResolution) ;
+        					return String.format( "%s:%s", name, type );
+        				})
         				.collect(Collectors.joining(", "))
         				;
 
@@ -299,7 +243,7 @@ private String getFactoryMethodDecl( final Method m, Class<?> declaringClass, ja
 
     		appendStaticMethodTypeParameters(sb, m);
 
-        sb.append( getMethodParametersDecl(m, declaringClass, declaredClassMap, false) );
+        sb.append( getMethodParametersAndReturnDecl(m, declaringClass, declaredClassMap, false) );
 
         return  sb.toString();
 
@@ -334,7 +278,7 @@ private String getMethodDecl( final Method m, Class<?> declaringClass, java.util
         }
 
         //if( m.getDeclaringClass().isInterface()) sb.append('?');
-        sb.append( getMethodParametersDecl(m, declaringClass, declaredClassMap, true) );
+        sb.append( getMethodParametersAndReturnDecl(m, declaringClass, declaredClassMap, true) );
 
         return  sb.toString();
 

processor/src/test/java/org/bsc/processor/RefrectionTest.java

@@ -149,6 +149,17 @@ public void testSample1() throws Exception {
 		Assert.assertThat( result, IsNull.notNullValue());		
 		Assert.assertThat( result, IsEqual.equalTo("E"));
 		}
+
+		{
+
+		final String[] arr = {};
+		final Method m = type.getMethod("method6", arr.getClass());	
+
+		final String result = processor.getMethodParametersAndReturnDecl( m, type, Collections.emptyMap(), true) ;
+
+		Assert.assertThat( result, IsNull.notNullValue());		
+		Assert.assertThat( result, IsEqual.equalTo("( ...arg0:string[] ):void"));
+		}
 
 	}
 }

processor/src/test/java/org/bsc/processor/Sample1.java

@@ -25,4 +25,6 @@ public interface Sample1<E> {
 	<C extends E> C method4();
 
 	<C extends Future<E>> C method5();
+
+	void method6( String ...args );
 }