test/langtools/tools/javac/cast/intersection/IntersectionTypeCastTest.java - platform/libcore - Git at Google

 /*
  * Copyright (c) 2012, 2015, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 2 only, as
  * published by the Free Software Foundation.
  *
  * This code is distributed in the hope that it will be useful, but WITHOUT
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  * version 2 for more details (a copy is included in the LICENSE file that
  * accompanied this code).
  *
  * You should have received a copy of the GNU General Public License version
  * 2 along with this work; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  *
  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  * or visit www.oracle.com if you need additional information or have any
  * questions.
  */

 /*
  * @test
  * @bug 8002099 8006694 8129962
  * @summary Add support for intersection types in cast expression
  *  temporarily workaround combo tests are causing time out in several platforms
  * @library /tools/javac/lib
  * @modules jdk.compiler/com.sun.tools.javac.api
  *          jdk.compiler/com.sun.tools.javac.code
  *          jdk.compiler/com.sun.tools.javac.comp
  *          jdk.compiler/com.sun.tools.javac.main
  *          jdk.compiler/com.sun.tools.javac.tree
  *          jdk.compiler/com.sun.tools.javac.util
  * @build combo.ComboTestHelper

  * @run main IntersectionTypeCastTest
  */

 import com.sun.tools.javac.util.List;

 import combo.ComboInstance;
 import combo.ComboParameter;
 import combo.ComboTask.Result;
 import combo.ComboTestHelper;

 import java.io.IOException;

 public class IntersectionTypeCastTest extends ComboInstance<IntersectionTypeCastTest> {

     interface Type extends ComboParameter {
         boolean subtypeOf(Type that);
         boolean isClass();
         boolean isInterface();
     }

     enum InterfaceKind implements Type {
         A("A", null),
         B("B", null),
         C("C", A);

         String typeStr;
         InterfaceKind superInterface;

         InterfaceKind(String typeStr, InterfaceKind superInterface) {
             this.typeStr = typeStr;
             this.superInterface = superInterface;
         }

         @Override
         public boolean subtypeOf(Type that) {
             return this == that || superInterface == that ||
                    that == ClassKind.OBJECT;
         }

         @Override
         public boolean isClass() {
             return false;
         }

         @Override
         public boolean isInterface() {
             return true;
         }

         @Override
         public String expand(String optParameter) {
             return typeStr;
         }
     }

     enum ClassKind implements Type {
         OBJECT("Object"),
         CA("CA", InterfaceKind.A),
         CB("CB", InterfaceKind.B),
         CAB("CAB", InterfaceKind.A, InterfaceKind.B),
         CC("CC", InterfaceKind.C, InterfaceKind.A),
         CCA("CCA", InterfaceKind.C, InterfaceKind.A),
         CCB("CCB", InterfaceKind.C, InterfaceKind.A, InterfaceKind.B),
         CCAB("CCAB", InterfaceKind.C, InterfaceKind.A, InterfaceKind.B);

         String typeStr;
         List<InterfaceKind> superInterfaces;

         ClassKind(String typeStr, InterfaceKind... superInterfaces) {
             this.typeStr = typeStr;
             this.superInterfaces = List.from(superInterfaces);
         }

         @Override
         public boolean subtypeOf(Type that) {
             return this == that || superInterfaces.contains(that) ||
                     that == OBJECT;
         }

         @Override
         public boolean isClass() {
             return true;
         }

         @Override
         public boolean isInterface() {
             return false;
         }

         @Override
         public String expand(String optParameter) {
             return typeStr;
         }
     }

     enum ModifierKind implements ComboParameter {
         NONE(""),
         FINAL("final");

         String modStr;

         ModifierKind(String modStr) {
             this.modStr = modStr;
         }

         @Override
         public String expand(String optParameter) {
             return modStr;
         }
     }

     enum CastKind implements ComboParameter {
         CLASS("(#{CLAZZ#IDX})", 0),
         INTERFACE("(#{INTF1#IDX})", 1),
         INTERSECTION2("(#{CLAZZ#IDX} & #{INTF1#IDX})", 1),
         INTERSECTION3("(#{CLAZZ#IDX} & #{INTF1#IDX} & #{INTF2#IDX})", 2);

         String castTemplate;
         int interfaceBounds;

         CastKind(String castTemplate, int interfaceBounds) {
             this.castTemplate = castTemplate;
             this.interfaceBounds = interfaceBounds;
         }

         @Override
         public String expand(String optParameter) {
             return castTemplate.replaceAll("#IDX", optParameter);
         }
     }

     static class CastInfo {
         CastKind kind;
         Type[] types;

         CastInfo(CastKind kind, Type... types) {
             this.kind = kind;
             this.types = types;
         }

         boolean hasDuplicateTypes() {
             for (int i = 0 ; i < arity() ; i++) {
                 for (int j = 0 ; j < arity() ; j++) {
                     if (i != j && types[i] == types[j]) {
                         return true;
                     }
                 }
             }
             return false;
         }

         boolean compatibleWith(ModifierKind mod, CastInfo that) {
             for (int i = 0 ; i < arity() ; i++) {
                 Type t1 = types[i];
                 for (int j = 0 ; j < that.arity() ; j++) {
                     Type t2 = that.types[j];
                     boolean compat =
                             t1.subtypeOf(t2) ||
                             t2.subtypeOf(t1) ||
                             (t1.isInterface() && t2.isInterface()) || //side-cast (1)
                             (mod == ModifierKind.NONE &&
                             (t1.isInterface() != t2.isInterface())); //side-cast (2)
                     if (!compat) return false;
                 }
             }
             return true;
         }

         private int arity() {
             return kind.interfaceBounds + 1;
         }
     }

     public static void main(String... args) throws Exception {
         new ComboTestHelper<IntersectionTypeCastTest>()
                 .withFilter(IntersectionTypeCastTest::isRedundantCast)
                 .withFilter(IntersectionTypeCastTest::arityFilter)
                 .withArrayDimension("CAST", (x, ck, idx) -> x.castKinds[idx] = ck, 2, CastKind.values())
                 .withDimension("CLAZZ1", (x, ty) -> x.types1[0] = ty, ClassKind.values())
                 .withDimension("INTF11", (x, ty) -> x.types1[1] = ty, InterfaceKind.values())
                 .withDimension("INTF21", (x, ty) -> x.types1[2] = ty, InterfaceKind.values())
                 .withDimension("CLAZZ2", (x, ty) -> x.types2[0] = ty, ClassKind.values())
                 .withDimension("INTF12", (x, ty) -> x.types2[1] = ty, InterfaceKind.values())
                 .withDimension("INTF22", (x, ty) -> x.types2[2] = ty, InterfaceKind.values())
                 .withDimension("MOD", (x, mod) -> x.mod = mod, ModifierKind.values())
                 .run(IntersectionTypeCastTest::new);
     }

     boolean isRedundantCast() {
         for (int i = 0 ; i < 2 ; i++) {
             Type[] types = i == 0 ? types1 : types2;
             if (castKinds[i] == CastKind.INTERFACE && types[0] != ClassKind.OBJECT) {
                 return false;
             }
         }
         return true;
     }

     boolean arityFilter() {
         for (int i = 0 ; i < 2 ; i++) {
             int lastPos = castKinds[i].interfaceBounds + 1;
             Type[] types = i == 0 ? types1 : types2;
             for (int j = 1; j < types.length; j++) {
                 boolean shouldBeSet = j < lastPos;
                 if (!shouldBeSet && (types[j] != InterfaceKind.A)) {
                     return false;
                 }
             }
         }
         return true;
     }

     ModifierKind mod;
     CastKind[] castKinds = new CastKind[2];
     Type[] types1 = new Type[3];
     Type[] types2 = new Type[3];

     @Override
     public void doWork() throws IOException {
         newCompilationTask()
                 .withSourceFromTemplate(bodyTemplate)
                 .analyze(this::check);
     }

     String bodyTemplate = "class Test {\n" +
                           "   void test() {\n" +
                           "      Object o = #{CAST[0].1}#{CAST[1].2}null;\n" +
                           "   } }\n" +
                           "interface A { }\n" +
                           "interface B { }\n" +
                           "interface C extends A { }\n" +
                           "#{MOD} class CA implements A { }\n" +
                           "#{MOD} class CB implements B { }\n" +
                           "#{MOD} class CAB implements A, B { }\n" +
                           "#{MOD} class CC implements C { }\n" +
                           "#{MOD} class CCA implements C, A { }\n" +
                           "#{MOD} class CCB implements C, B { }\n" +
                           "#{MOD} class CCAB implements C, A, B { }";

     void check(Result<?> res) {
         CastInfo cast1 = new CastInfo(castKinds[0], types1);
         CastInfo cast2 = new CastInfo(castKinds[1], types2);
         boolean errorExpected = cast1.hasDuplicateTypes() ||
                 cast2.hasDuplicateTypes();

         errorExpected |= !cast2.compatibleWith(mod, cast1);

         boolean errorsFound = res.hasErrors();
         if (errorExpected != errorsFound) {
             fail("invalid diagnostics for source:\n" +
                 res.compilationInfo() +
                 "\nFound error: " + errorsFound +
                 "\nExpected error: " + errorExpected);
         }
     }
 }
	/*
	* Copyright (c) 2012, 2015, Oracle and/or its affiliates. All rights reserved.
	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	*
	* This code is free software; you can redistribute it and/or modify it
	* under the terms of the GNU General Public License version 2 only, as
	* published by the Free Software Foundation.
	*
	* This code is distributed in the hope that it will be useful, but WITHOUT
	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	* version 2 for more details (a copy is included in the LICENSE file that
	* accompanied this code).
	*
	* You should have received a copy of the GNU General Public License version
	* 2 along with this work; if not, write to the Free Software Foundation,
	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	*
	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	* or visit www.oracle.com if you need additional information or have any
	* questions.
	*/

	/*
	* @test
	* @bug 8002099 8006694 8129962
	* @summary Add support for intersection types in cast expression
	* temporarily workaround combo tests are causing time out in several platforms
	* @library /tools/javac/lib
	* @modules jdk.compiler/com.sun.tools.javac.api
	* jdk.compiler/com.sun.tools.javac.code
	* jdk.compiler/com.sun.tools.javac.comp
	* jdk.compiler/com.sun.tools.javac.main
	* jdk.compiler/com.sun.tools.javac.tree
	* jdk.compiler/com.sun.tools.javac.util
	* @build combo.ComboTestHelper

	* @run main IntersectionTypeCastTest
	*/

	import com.sun.tools.javac.util.List;

	import combo.ComboInstance;
	import combo.ComboParameter;
	import combo.ComboTask.Result;
	import combo.ComboTestHelper;

	import java.io.IOException;

	public class IntersectionTypeCastTest extends ComboInstance<IntersectionTypeCastTest> {

	interface Type extends ComboParameter {
	boolean subtypeOf(Type that);
	boolean isClass();
	boolean isInterface();
	}

	enum InterfaceKind implements Type {
	A("A", null),
	B("B", null),
	C("C", A);

	String typeStr;
	InterfaceKind superInterface;

	InterfaceKind(String typeStr, InterfaceKind superInterface) {
	this.typeStr = typeStr;
	this.superInterface = superInterface;
	}

	@Override
	public boolean subtypeOf(Type that) {
	return this == that \|\| superInterface == that \|\|
	that == ClassKind.OBJECT;
	}

	@Override
	public boolean isClass() {
	return false;
	}

	@Override
	public boolean isInterface() {
	return true;
	}

	@Override
	public String expand(String optParameter) {
	return typeStr;
	}
	}

	enum ClassKind implements Type {
	OBJECT("Object"),
	CA("CA", InterfaceKind.A),
	CB("CB", InterfaceKind.B),
	CAB("CAB", InterfaceKind.A, InterfaceKind.B),
	CC("CC", InterfaceKind.C, InterfaceKind.A),
	CCA("CCA", InterfaceKind.C, InterfaceKind.A),
	CCB("CCB", InterfaceKind.C, InterfaceKind.A, InterfaceKind.B),
	CCAB("CCAB", InterfaceKind.C, InterfaceKind.A, InterfaceKind.B);

	String typeStr;
	List<InterfaceKind> superInterfaces;

	ClassKind(String typeStr, InterfaceKind... superInterfaces) {
	this.typeStr = typeStr;
	this.superInterfaces = List.from(superInterfaces);
	}

	@Override
	public boolean subtypeOf(Type that) {
	return this == that \|\| superInterfaces.contains(that) \|\|
	that == OBJECT;
	}

	@Override
	public boolean isClass() {
	return true;
	}

	@Override
	public boolean isInterface() {
	return false;
	}

	@Override
	public String expand(String optParameter) {
	return typeStr;
	}
	}

	enum ModifierKind implements ComboParameter {
	NONE(""),
	FINAL("final");

	String modStr;

	ModifierKind(String modStr) {
	this.modStr = modStr;
	}

	@Override
	public String expand(String optParameter) {
	return modStr;
	}
	}

	enum CastKind implements ComboParameter {
	CLASS("(#{CLAZZ#IDX})", 0),
	INTERFACE("(#{INTF1#IDX})", 1),
	INTERSECTION2("(#{CLAZZ#IDX} & #{INTF1#IDX})", 1),
	INTERSECTION3("(#{CLAZZ#IDX} & #{INTF1#IDX} & #{INTF2#IDX})", 2);

	String castTemplate;
	int interfaceBounds;

	CastKind(String castTemplate, int interfaceBounds) {
	this.castTemplate = castTemplate;
	this.interfaceBounds = interfaceBounds;
	}

	@Override
	public String expand(String optParameter) {
	return castTemplate.replaceAll("#IDX", optParameter);
	}
	}

	static class CastInfo {
	CastKind kind;
	Type[] types;

	CastInfo(CastKind kind, Type... types) {
	this.kind = kind;
	this.types = types;
	}

	boolean hasDuplicateTypes() {
	for (int i = 0 ; i < arity() ; i++) {
	for (int j = 0 ; j < arity() ; j++) {
	if (i != j && types[i] == types[j]) {
	return true;
	}
	}
	}
	return false;
	}

	boolean compatibleWith(ModifierKind mod, CastInfo that) {
	for (int i = 0 ; i < arity() ; i++) {
	Type t1 = types[i];
	for (int j = 0 ; j < that.arity() ; j++) {
	Type t2 = that.types[j];
	boolean compat =
	t1.subtypeOf(t2) \|\|
	t2.subtypeOf(t1) \|\|
	(t1.isInterface() && t2.isInterface()) \|\| //side-cast (1)
	(mod == ModifierKind.NONE &&
	(t1.isInterface() != t2.isInterface())); //side-cast (2)
	if (!compat) return false;
	}
	}
	return true;
	}

	private int arity() {
	return kind.interfaceBounds + 1;
	}
	}

	public static void main(String... args) throws Exception {
	new ComboTestHelper<IntersectionTypeCastTest>()
	.withFilter(IntersectionTypeCastTest::isRedundantCast)
	.withFilter(IntersectionTypeCastTest::arityFilter)
	.withArrayDimension("CAST", (x, ck, idx) -> x.castKinds[idx] = ck, 2, CastKind.values())
	.withDimension("CLAZZ1", (x, ty) -> x.types1[0] = ty, ClassKind.values())
	.withDimension("INTF11", (x, ty) -> x.types1[1] = ty, InterfaceKind.values())
	.withDimension("INTF21", (x, ty) -> x.types1[2] = ty, InterfaceKind.values())
	.withDimension("CLAZZ2", (x, ty) -> x.types2[0] = ty, ClassKind.values())
	.withDimension("INTF12", (x, ty) -> x.types2[1] = ty, InterfaceKind.values())
	.withDimension("INTF22", (x, ty) -> x.types2[2] = ty, InterfaceKind.values())
	.withDimension("MOD", (x, mod) -> x.mod = mod, ModifierKind.values())
	.run(IntersectionTypeCastTest::new);
	}

	boolean isRedundantCast() {
	for (int i = 0 ; i < 2 ; i++) {
	Type[] types = i == 0 ? types1 : types2;
	if (castKinds[i] == CastKind.INTERFACE && types[0] != ClassKind.OBJECT) {
	return false;
	}
	}
	return true;
	}

	boolean arityFilter() {
	for (int i = 0 ; i < 2 ; i++) {
	int lastPos = castKinds[i].interfaceBounds + 1;
	Type[] types = i == 0 ? types1 : types2;
	for (int j = 1; j < types.length; j++) {
	boolean shouldBeSet = j < lastPos;
	if (!shouldBeSet && (types[j] != InterfaceKind.A)) {
	return false;
	}
	}
	}
	return true;
	}

	ModifierKind mod;
	CastKind[] castKinds = new CastKind[2];
	Type[] types1 = new Type[3];
	Type[] types2 = new Type[3];

	@Override
	public void doWork() throws IOException {
	newCompilationTask()
	.withSourceFromTemplate(bodyTemplate)
	.analyze(this::check);
	}

	String bodyTemplate = "class Test {\n" +
	" void test() {\n" +
	" Object o = #{CAST[0].1}#{CAST[1].2}null;\n" +
	" } }\n" +
	"interface A { }\n" +
	"interface B { }\n" +
	"interface C extends A { }\n" +
	"#{MOD} class CA implements A { }\n" +
	"#{MOD} class CB implements B { }\n" +
	"#{MOD} class CAB implements A, B { }\n" +
	"#{MOD} class CC implements C { }\n" +
	"#{MOD} class CCA implements C, A { }\n" +
	"#{MOD} class CCB implements C, B { }\n" +
	"#{MOD} class CCAB implements C, A, B { }";

	void check(Result<?> res) {
	CastInfo cast1 = new CastInfo(castKinds[0], types1);
	CastInfo cast2 = new CastInfo(castKinds[1], types2);
	boolean errorExpected = cast1.hasDuplicateTypes() \|\|
	cast2.hasDuplicateTypes();

	errorExpected \|= !cast2.compatibleWith(mod, cast1);

	boolean errorsFound = res.hasErrors();
	if (errorExpected != errorsFound) {
	fail("invalid diagnostics for source:\n" +
	res.compilationInfo() +
	"\nFound error: " + errorsFound +
	"\nExpected error: " + errorExpected);
	}
	}
	}