From 1e7e3238847aa2e90e16f107b2fa8c52bd6713c0 Mon Sep 17 00:00:00 2001 From: Haifeng Shi Date: Fri, 10 Mar 2023 16:31:07 -0500 Subject: [PATCH 01/11] apply flow-refinement for receiver when using getAnnotatedTypeLHS --- .../framework/type/AnnotatedTypeFactory.java | 9 +++++ .../type/GenericAnnotatedTypeFactory.java | 9 +++++ .../type/TypeFromExpressionVisitor.java | 5 ++- .../viewpointtest/TestgetAnnotatedLHS.java | 35 +++++++++++++++++++ 4 files changed, 57 insertions(+), 1 deletion(-) create mode 100644 framework/tests/viewpointtest/TestgetAnnotatedLHS.java diff --git a/framework/src/main/java/org/checkerframework/framework/type/AnnotatedTypeFactory.java b/framework/src/main/java/org/checkerframework/framework/type/AnnotatedTypeFactory.java index 70d228d62be3..1d18c115ab73 100644 --- a/framework/src/main/java/org/checkerframework/framework/type/AnnotatedTypeFactory.java +++ b/framework/src/main/java/org/checkerframework/framework/type/AnnotatedTypeFactory.java @@ -3407,6 +3407,15 @@ public final AnnotatedExecutableType getAnnotatedType(ExecutableElement elt) { return (AnnotatedExecutableType) getAnnotatedType((Element) elt); } + /** + * See {@link #getAnnotatedType(Tree)}. + * + * @see #getAnnotatedType(Tree) + */ + public AnnotatedTypeMirror getAnnotatedTypeWithReceiverRefinement(Tree tree) { + return getAnnotatedType(tree); + } + /** * See {@link #fromElement(Element)}. * diff --git a/framework/src/main/java/org/checkerframework/framework/type/GenericAnnotatedTypeFactory.java b/framework/src/main/java/org/checkerframework/framework/type/GenericAnnotatedTypeFactory.java index d85c3bc5978c..16edaddb78e1 100644 --- a/framework/src/main/java/org/checkerframework/framework/type/GenericAnnotatedTypeFactory.java +++ b/framework/src/main/java/org/checkerframework/framework/type/GenericAnnotatedTypeFactory.java @@ -1702,6 +1702,15 @@ public AnnotatedTypeMirror getAnnotatedTypeLhs(Tree lhsTree) { return res; } + @Override + public AnnotatedTypeMirror getAnnotatedTypeWithReceiverRefinement(Tree tree) { + boolean oldUseFlow = useFlow; + useFlow = everUseFlow; + AnnotatedTypeMirror result = getAnnotatedType(tree); + useFlow = oldUseFlow; + return result; + } + /** * Returns the type of a varargs array of a method invocation or a constructor invocation. * Returns null only if private field {@code useFlow} is false. diff --git a/framework/src/main/java/org/checkerframework/framework/type/TypeFromExpressionVisitor.java b/framework/src/main/java/org/checkerframework/framework/type/TypeFromExpressionVisitor.java index c1385a64a0f8..2910593b4d65 100644 --- a/framework/src/main/java/org/checkerframework/framework/type/TypeFromExpressionVisitor.java +++ b/framework/src/main/java/org/checkerframework/framework/type/TypeFromExpressionVisitor.java @@ -270,7 +270,10 @@ public AnnotatedTypeMirror visitMemberSelect(MemberSelectTree tree, AnnotatedTyp } else { // tree must be a field access, so get the type of the expression, and then call // asMemberOf. - AnnotatedTypeMirror t = f.getAnnotatedType(tree.getExpression()); + // As long as everuseflow is true, always have flow-refinement for receiver. + // That means, even when using method getAnnotatedTypeLHS, receiver will have + // flow-refinement. + AnnotatedTypeMirror t = f.getAnnotatedTypeWithReceiverRefinement(tree.getExpression()); t = f.applyCaptureConversion(t); return AnnotatedTypes.asMemberOf(f.types, f, t, elt).asUse(); } diff --git a/framework/tests/viewpointtest/TestgetAnnotatedLHS.java b/framework/tests/viewpointtest/TestgetAnnotatedLHS.java new file mode 100644 index 000000000000..1d50f895b2a6 --- /dev/null +++ b/framework/tests/viewpointtest/TestgetAnnotatedLHS.java @@ -0,0 +1,35 @@ +import viewpointtest.quals.A; +import viewpointtest.quals.B; +import viewpointtest.quals.ReceiverDependentQual; +import viewpointtest.quals.Top; + +@ReceiverDependentQual +class TestgetAnnotatedLHS { + @ReceiverDependentQual Object f; + + @SuppressWarnings({ + "inconsistent.constructor.type", + "super.invocation.invalid", + "cast.unsafe.constructor.invocation" + }) + @ReceiverDependentQual + TestgetAnnotatedLHS() { + this.f = new @ReceiverDependentQual Object(); + } + + @SuppressWarnings({"cast.unsafe.constructor.invocation"}) + void topWithRefinement() { + TestgetAnnotatedLHS a = new @A TestgetAnnotatedLHS(); + TestgetAnnotatedLHS top = new @Top TestgetAnnotatedLHS(); + top = a; + // :: error: (assignment.type.incompatible) + top.f = new @B Object(); + top.f = new @A Object(); // no error here + } + + @SuppressWarnings({"cast.unsafe.constructor.invocation"}) + void topWithoutRefinement() { + TestgetAnnotatedLHS top = new @Top TestgetAnnotatedLHS(); + top.f = new @A Object(); + } +} From c3a50df4364066b82a04973bb7b165b940ef01e6 Mon Sep 17 00:00:00 2001 From: Haifeng Shi Date: Fri, 10 Mar 2023 16:51:30 -0500 Subject: [PATCH 02/11] fix misc --- .../checkerframework/framework/type/AnnotatedTypeFactory.java | 3 ++- .../framework/type/GenericAnnotatedTypeFactory.java | 1 + 2 files changed, 3 insertions(+), 1 deletion(-) diff --git a/framework/src/main/java/org/checkerframework/framework/type/AnnotatedTypeFactory.java b/framework/src/main/java/org/checkerframework/framework/type/AnnotatedTypeFactory.java index 1d18c115ab73..464e83d8fb9e 100644 --- a/framework/src/main/java/org/checkerframework/framework/type/AnnotatedTypeFactory.java +++ b/framework/src/main/java/org/checkerframework/framework/type/AnnotatedTypeFactory.java @@ -3410,7 +3410,8 @@ public final AnnotatedExecutableType getAnnotatedType(ExecutableElement elt) { /** * See {@link #getAnnotatedType(Tree)}. * - * @see #getAnnotatedType(Tree) + * @param tree tree + * @return Annotated type of the tree */ public AnnotatedTypeMirror getAnnotatedTypeWithReceiverRefinement(Tree tree) { return getAnnotatedType(tree); diff --git a/framework/src/main/java/org/checkerframework/framework/type/GenericAnnotatedTypeFactory.java b/framework/src/main/java/org/checkerframework/framework/type/GenericAnnotatedTypeFactory.java index 16edaddb78e1..97508514c8f1 100644 --- a/framework/src/main/java/org/checkerframework/framework/type/GenericAnnotatedTypeFactory.java +++ b/framework/src/main/java/org/checkerframework/framework/type/GenericAnnotatedTypeFactory.java @@ -1702,6 +1702,7 @@ public AnnotatedTypeMirror getAnnotatedTypeLhs(Tree lhsTree) { return res; } + /* As long as the everUseFlow is true, always enable flow refinement for the receiver */ @Override public AnnotatedTypeMirror getAnnotatedTypeWithReceiverRefinement(Tree tree) { boolean oldUseFlow = useFlow; From d75b31d74a1150076b1dbb5f6342f5f01c9501a0 Mon Sep 17 00:00:00 2001 From: Haifeng Shi Date: Tue, 27 Jun 2023 21:06:33 -0400 Subject: [PATCH 03/11] grammar fix Co-authored-by: Werner Dietl --- .../framework/type/GenericAnnotatedTypeFactory.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/framework/src/main/java/org/checkerframework/framework/type/GenericAnnotatedTypeFactory.java b/framework/src/main/java/org/checkerframework/framework/type/GenericAnnotatedTypeFactory.java index 9bbf0ee13751..d8e8e0034d6b 100644 --- a/framework/src/main/java/org/checkerframework/framework/type/GenericAnnotatedTypeFactory.java +++ b/framework/src/main/java/org/checkerframework/framework/type/GenericAnnotatedTypeFactory.java @@ -1702,7 +1702,7 @@ public AnnotatedTypeMirror getAnnotatedTypeLhs(Tree lhsTree) { return res; } - /* As long as the everUseFlow is true, always enable flow refinement for the receiver */ + /* As long as everUseFlow is true, always enable flow refinement for the receiver. */ @Override public AnnotatedTypeMirror getAnnotatedTypeWithReceiverRefinement(Tree tree) { boolean oldUseFlow = useFlow; From ce3bcc22646939106e621f5368629d36bc357f4b Mon Sep 17 00:00:00 2001 From: Haifeng Shi Date: Tue, 27 Jun 2023 22:09:39 -0400 Subject: [PATCH 04/11] add more explanation to the feature --- .../framework/type/AnnotatedTypeFactory.java | 10 ---------- .../type/GenericAnnotatedTypeFactory.java | 1 - .../type/TypeFromExpressionVisitor.java | 20 +++++++++++++++---- .../viewpointtest/TestgetAnnotatedLHS.java | 6 ++++++ 4 files changed, 22 insertions(+), 15 deletions(-) diff --git a/framework/src/main/java/org/checkerframework/framework/type/AnnotatedTypeFactory.java b/framework/src/main/java/org/checkerframework/framework/type/AnnotatedTypeFactory.java index 3839891e58f5..798b63101cc1 100644 --- a/framework/src/main/java/org/checkerframework/framework/type/AnnotatedTypeFactory.java +++ b/framework/src/main/java/org/checkerframework/framework/type/AnnotatedTypeFactory.java @@ -3493,16 +3493,6 @@ public final AnnotatedExecutableType getAnnotatedType(ExecutableElement elt) { return (AnnotatedExecutableType) getAnnotatedType((Element) elt); } - /** - * See {@link #getAnnotatedType(Tree)}. - * - * @param tree tree - * @return Annotated type of the tree - */ - public AnnotatedTypeMirror getAnnotatedTypeWithReceiverRefinement(Tree tree) { - return getAnnotatedType(tree); - } - /** * See {@link #fromElement(Element)}. * diff --git a/framework/src/main/java/org/checkerframework/framework/type/GenericAnnotatedTypeFactory.java b/framework/src/main/java/org/checkerframework/framework/type/GenericAnnotatedTypeFactory.java index d8e8e0034d6b..c00b8edde54d 100644 --- a/framework/src/main/java/org/checkerframework/framework/type/GenericAnnotatedTypeFactory.java +++ b/framework/src/main/java/org/checkerframework/framework/type/GenericAnnotatedTypeFactory.java @@ -1703,7 +1703,6 @@ public AnnotatedTypeMirror getAnnotatedTypeLhs(Tree lhsTree) { } /* As long as everUseFlow is true, always enable flow refinement for the receiver. */ - @Override public AnnotatedTypeMirror getAnnotatedTypeWithReceiverRefinement(Tree tree) { boolean oldUseFlow = useFlow; useFlow = everUseFlow; diff --git a/framework/src/main/java/org/checkerframework/framework/type/TypeFromExpressionVisitor.java b/framework/src/main/java/org/checkerframework/framework/type/TypeFromExpressionVisitor.java index 2910593b4d65..cadf92037925 100644 --- a/framework/src/main/java/org/checkerframework/framework/type/TypeFromExpressionVisitor.java +++ b/framework/src/main/java/org/checkerframework/framework/type/TypeFromExpressionVisitor.java @@ -270,10 +270,22 @@ public AnnotatedTypeMirror visitMemberSelect(MemberSelectTree tree, AnnotatedTyp } else { // tree must be a field access, so get the type of the expression, and then call // asMemberOf. - // As long as everuseflow is true, always have flow-refinement for receiver. - // That means, even when using method getAnnotatedTypeLHS, receiver will have - // flow-refinement. - AnnotatedTypeMirror t = f.getAnnotatedTypeWithReceiverRefinement(tree.getExpression()); + AnnotatedTypeMirror t; + if (f instanceof GenericAnnotatedTypeFactory) { + // If calling GenericAnnotatedTypeFactory#getAnnotatedTypeLhs(Tree lhsTree) to + // get the type of this MemberSelectTree, flow refinement is disabled. However, + // we want the receiver to have the refined type because type + // systems can use receiver-dependent qualifiers for viewpoint adaptation. + // Thus, we re-enable the flow refinement for a while just for the receiver + // expression. + // See framework/tests/viewpointtest/TestgetAnnotatedLHS.java:26 for a concrete + // example. + t = + ((GenericAnnotatedTypeFactory) f) + .getAnnotatedTypeWithReceiverRefinement(tree.getExpression()); + } else { + t = f.getAnnotatedType(tree.getExpression()); + } t = f.applyCaptureConversion(t); return AnnotatedTypes.asMemberOf(f.types, f, t, elt).asUse(); } diff --git a/framework/tests/viewpointtest/TestgetAnnotatedLHS.java b/framework/tests/viewpointtest/TestgetAnnotatedLHS.java index 1d50f895b2a6..4d1d0bf9810e 100644 --- a/framework/tests/viewpointtest/TestgetAnnotatedLHS.java +++ b/framework/tests/viewpointtest/TestgetAnnotatedLHS.java @@ -22,6 +22,12 @@ void topWithRefinement() { TestgetAnnotatedLHS a = new @A TestgetAnnotatedLHS(); TestgetAnnotatedLHS top = new @Top TestgetAnnotatedLHS(); top = a; + // When checking the below assignment, GenericAnnotatedTypeFactory#getAnnotatedTypeLhs() + // will be called to get the type of the lhs tree (top.f). + // Previously this method will completely disable flow refinment, and top.f will have type + // @Top and thus accept the below assingment. But we should reject it, as top + // is refined to be @A before. As long as top is still pointing to the @A object, top.f + // will have type @A, which is not the supertype of @B. // :: error: (assignment.type.incompatible) top.f = new @B Object(); top.f = new @A Object(); // no error here From b133a42792beab459b8ed3a7296d1f3789d0e9c6 Mon Sep 17 00:00:00 2001 From: Haifeng Shi Date: Wed, 28 Jun 2023 12:02:22 -0400 Subject: [PATCH 05/11] add javadoc --- .../framework/type/GenericAnnotatedTypeFactory.java | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/framework/src/main/java/org/checkerframework/framework/type/GenericAnnotatedTypeFactory.java b/framework/src/main/java/org/checkerframework/framework/type/GenericAnnotatedTypeFactory.java index c00b8edde54d..a740a8e1fd5d 100644 --- a/framework/src/main/java/org/checkerframework/framework/type/GenericAnnotatedTypeFactory.java +++ b/framework/src/main/java/org/checkerframework/framework/type/GenericAnnotatedTypeFactory.java @@ -1702,7 +1702,12 @@ public AnnotatedTypeMirror getAnnotatedTypeLhs(Tree lhsTree) { return res; } - /* As long as everUseFlow is true, always enable flow refinement for the receiver. */ + /** + * As long as everUseFlow is true, always enable flow refinement for the receiver. + * + * @param tree an expression tree + * @return the refined type of the expression tree + */ public AnnotatedTypeMirror getAnnotatedTypeWithReceiverRefinement(Tree tree) { boolean oldUseFlow = useFlow; useFlow = everUseFlow; From 8de8fdc35d4473290207eef6c223d8b43b1a3bb6 Mon Sep 17 00:00:00 2001 From: Haifeng Shi Date: Thu, 31 Aug 2023 18:46:17 -0400 Subject: [PATCH 06/11] change method visibility --- .../framework/type/GenericAnnotatedTypeFactory.java | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/framework/src/main/java/org/checkerframework/framework/type/GenericAnnotatedTypeFactory.java b/framework/src/main/java/org/checkerframework/framework/type/GenericAnnotatedTypeFactory.java index a740a8e1fd5d..d92a133eb5a5 100644 --- a/framework/src/main/java/org/checkerframework/framework/type/GenericAnnotatedTypeFactory.java +++ b/framework/src/main/java/org/checkerframework/framework/type/GenericAnnotatedTypeFactory.java @@ -1703,12 +1703,14 @@ public AnnotatedTypeMirror getAnnotatedTypeLhs(Tree lhsTree) { } /** - * As long as everUseFlow is true, always enable flow refinement for the receiver. + * As long as everUseFlow is true, always enable flow refinement for the receiver. This method + * is an implementation detail and visible inside the package only. * + * @see #getAnnotatedType(Tree), which should be used to get the annotated type. * @param tree an expression tree * @return the refined type of the expression tree */ - public AnnotatedTypeMirror getAnnotatedTypeWithReceiverRefinement(Tree tree) { + AnnotatedTypeMirror getAnnotatedTypeWithReceiverRefinement(Tree tree) { boolean oldUseFlow = useFlow; useFlow = everUseFlow; AnnotatedTypeMirror result = getAnnotatedType(tree); From cbd78237510db476bac8917e41d735de5d7cce38 Mon Sep 17 00:00:00 2001 From: Haifeng Shi Date: Thu, 31 Aug 2023 18:50:19 -0400 Subject: [PATCH 07/11] add more explanation --- .../framework/type/GenericAnnotatedTypeFactory.java | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/framework/src/main/java/org/checkerframework/framework/type/GenericAnnotatedTypeFactory.java b/framework/src/main/java/org/checkerframework/framework/type/GenericAnnotatedTypeFactory.java index d92a133eb5a5..c9033c6661d9 100644 --- a/framework/src/main/java/org/checkerframework/framework/type/GenericAnnotatedTypeFactory.java +++ b/framework/src/main/java/org/checkerframework/framework/type/GenericAnnotatedTypeFactory.java @@ -1704,9 +1704,10 @@ public AnnotatedTypeMirror getAnnotatedTypeLhs(Tree lhsTree) { /** * As long as everUseFlow is true, always enable flow refinement for the receiver. This method - * is an implementation detail and visible inside the package only. + * is an implementation detail and visible inside the package only. See the comment in this + * testcase for more details framework/tests/viewpointtest/TestgetAnnotatedLHS.java. * - * @see #getAnnotatedType(Tree), which should be used to get the annotated type. + * @see #getAnnotatedType(Tree), which should be usually used to get the annotated type. * @param tree an expression tree * @return the refined type of the expression tree */ From 54100f55c87e569f839c60ea5b30f659a3441301 Mon Sep 17 00:00:00 2001 From: Haifeng Shi Date: Fri, 1 Sep 2023 11:10:09 -0400 Subject: [PATCH 08/11] fix misc --- .../framework/type/GenericAnnotatedTypeFactory.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/framework/src/main/java/org/checkerframework/framework/type/GenericAnnotatedTypeFactory.java b/framework/src/main/java/org/checkerframework/framework/type/GenericAnnotatedTypeFactory.java index c9033c6661d9..8c3dd5378fe6 100644 --- a/framework/src/main/java/org/checkerframework/framework/type/GenericAnnotatedTypeFactory.java +++ b/framework/src/main/java/org/checkerframework/framework/type/GenericAnnotatedTypeFactory.java @@ -1707,7 +1707,7 @@ public AnnotatedTypeMirror getAnnotatedTypeLhs(Tree lhsTree) { * is an implementation detail and visible inside the package only. See the comment in this * testcase for more details framework/tests/viewpointtest/TestgetAnnotatedLHS.java. * - * @see #getAnnotatedType(Tree), which should be usually used to get the annotated type. + * @see #getAnnotatedType(Tree) * @param tree an expression tree * @return the refined type of the expression tree */ From 5e27d51f9f37e7e99611473356ac7e212411bc5a Mon Sep 17 00:00:00 2001 From: Haifeng Shi Date: Tue, 26 Sep 2023 23:01:21 -0400 Subject: [PATCH 09/11] Apply suggestions from code review Co-authored-by: Werner Dietl --- .../framework/type/GenericAnnotatedTypeFactory.java | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/framework/src/main/java/org/checkerframework/framework/type/GenericAnnotatedTypeFactory.java b/framework/src/main/java/org/checkerframework/framework/type/GenericAnnotatedTypeFactory.java index 64c104d57c78..d0efa60708e5 100644 --- a/framework/src/main/java/org/checkerframework/framework/type/GenericAnnotatedTypeFactory.java +++ b/framework/src/main/java/org/checkerframework/framework/type/GenericAnnotatedTypeFactory.java @@ -1787,10 +1787,11 @@ public AnnotatedTypeMirror getAnnotatedTypeLhs(Tree lhsTree) { * testcase for more details framework/tests/viewpointtest/TestgetAnnotatedLHS.java. * * @see #getAnnotatedType(Tree) + * @see #getAnnotatedTypeLhs(Tree) * @param tree an expression tree * @return the refined type of the expression tree */ - AnnotatedTypeMirror getAnnotatedTypeWithReceiverRefinement(Tree tree) { + /*package-private*/ AnnotatedTypeMirror getAnnotatedTypeWithReceiverRefinement(Tree tree) { boolean oldUseFlow = useFlow; useFlow = everUseFlow; AnnotatedTypeMirror result = getAnnotatedType(tree); From 7e509ad09438b35135da04cc9df3d0231e5ceec6 Mon Sep 17 00:00:00 2001 From: Haifeng Shi Date: Tue, 26 Sep 2023 23:11:40 -0400 Subject: [PATCH 10/11] address comments --- .../framework/type/GenericAnnotatedTypeFactory.java | 2 +- .../framework/type/TypeFromExpressionVisitor.java | 2 +- ...getAnnotatedLHS.java => TestGetAnnotatedLhs.java} | 12 +++++++----- 3 files changed, 9 insertions(+), 7 deletions(-) rename framework/tests/viewpointtest/{TestgetAnnotatedLHS.java => TestGetAnnotatedLhs.java} (80%) diff --git a/framework/src/main/java/org/checkerframework/framework/type/GenericAnnotatedTypeFactory.java b/framework/src/main/java/org/checkerframework/framework/type/GenericAnnotatedTypeFactory.java index d0efa60708e5..c5d74be41bb1 100644 --- a/framework/src/main/java/org/checkerframework/framework/type/GenericAnnotatedTypeFactory.java +++ b/framework/src/main/java/org/checkerframework/framework/type/GenericAnnotatedTypeFactory.java @@ -1784,7 +1784,7 @@ public AnnotatedTypeMirror getAnnotatedTypeLhs(Tree lhsTree) { /** * As long as everUseFlow is true, always enable flow refinement for the receiver. This method * is an implementation detail and visible inside the package only. See the comment in this - * testcase for more details framework/tests/viewpointtest/TestgetAnnotatedLHS.java. + * testcase for more details framework/tests/viewpointtest/TestGetAnnotatedLhs.java. * * @see #getAnnotatedType(Tree) * @see #getAnnotatedTypeLhs(Tree) diff --git a/framework/src/main/java/org/checkerframework/framework/type/TypeFromExpressionVisitor.java b/framework/src/main/java/org/checkerframework/framework/type/TypeFromExpressionVisitor.java index cadf92037925..d96d244f8c9c 100644 --- a/framework/src/main/java/org/checkerframework/framework/type/TypeFromExpressionVisitor.java +++ b/framework/src/main/java/org/checkerframework/framework/type/TypeFromExpressionVisitor.java @@ -278,7 +278,7 @@ public AnnotatedTypeMirror visitMemberSelect(MemberSelectTree tree, AnnotatedTyp // systems can use receiver-dependent qualifiers for viewpoint adaptation. // Thus, we re-enable the flow refinement for a while just for the receiver // expression. - // See framework/tests/viewpointtest/TestgetAnnotatedLHS.java:26 for a concrete + // See framework/tests/viewpointtest/TestGetAnnotatedLhs.java for a concrete // example. t = ((GenericAnnotatedTypeFactory) f) diff --git a/framework/tests/viewpointtest/TestgetAnnotatedLHS.java b/framework/tests/viewpointtest/TestGetAnnotatedLhs.java similarity index 80% rename from framework/tests/viewpointtest/TestgetAnnotatedLHS.java rename to framework/tests/viewpointtest/TestGetAnnotatedLhs.java index 4d1d0bf9810e..96a98d60171d 100644 --- a/framework/tests/viewpointtest/TestgetAnnotatedLHS.java +++ b/framework/tests/viewpointtest/TestGetAnnotatedLhs.java @@ -4,7 +4,7 @@ import viewpointtest.quals.Top; @ReceiverDependentQual -class TestgetAnnotatedLHS { +class TestGetAnnotatedLhs { @ReceiverDependentQual Object f; @SuppressWarnings({ @@ -13,14 +13,14 @@ class TestgetAnnotatedLHS { "cast.unsafe.constructor.invocation" }) @ReceiverDependentQual - TestgetAnnotatedLHS() { + TestGetAnnotatedLhs() { this.f = new @ReceiverDependentQual Object(); } @SuppressWarnings({"cast.unsafe.constructor.invocation"}) void topWithRefinement() { - TestgetAnnotatedLHS a = new @A TestgetAnnotatedLHS(); - TestgetAnnotatedLHS top = new @Top TestgetAnnotatedLHS(); + TestGetAnnotatedLhs a = new @A TestGetAnnotatedLhs(); + TestGetAnnotatedLhs top = new @Top TestGetAnnotatedLhs(); top = a; // When checking the below assignment, GenericAnnotatedTypeFactory#getAnnotatedTypeLhs() // will be called to get the type of the lhs tree (top.f). @@ -35,7 +35,9 @@ void topWithRefinement() { @SuppressWarnings({"cast.unsafe.constructor.invocation"}) void topWithoutRefinement() { - TestgetAnnotatedLHS top = new @Top TestgetAnnotatedLHS(); + TestGetAnnotatedLhs top = new @Top TestGetAnnotatedLhs(); + // :: error: (assignment.type.incompatible) + top.f = new @B Object(); top.f = new @A Object(); } } From 0254f6085bfc09c825ea992a186f930c8ab6fa1e Mon Sep 17 00:00:00 2001 From: Werner Dietl Date: Fri, 29 Sep 2023 17:49:28 -0400 Subject: [PATCH 11/11] Refer to issue --- framework/tests/viewpointtest/TestGetAnnotatedLhs.java | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/framework/tests/viewpointtest/TestGetAnnotatedLhs.java b/framework/tests/viewpointtest/TestGetAnnotatedLhs.java index 96a98d60171d..71641a91a717 100644 --- a/framework/tests/viewpointtest/TestGetAnnotatedLhs.java +++ b/framework/tests/viewpointtest/TestGetAnnotatedLhs.java @@ -36,7 +36,8 @@ void topWithRefinement() { @SuppressWarnings({"cast.unsafe.constructor.invocation"}) void topWithoutRefinement() { TestGetAnnotatedLhs top = new @Top TestGetAnnotatedLhs(); - // :: error: (assignment.type.incompatible) + // See #576. + // :TODO: error: (assignment.type.incompatible) top.f = new @B Object(); top.f = new @A Object(); }