Add assert refinement to temporary annotations

shannonzhu · facebook-github-bot · commit d2082a91a8b9 · 2021-08-19T11:08:28.000-07:00
Summary:
If there are no interleaving calls between  refinement of a non-final attribute, store the refined annotation in temporary annotations.

its_happening

Reviewed By: grievejia

Differential Revision: D30412120

fbshipit-source-id: c64a530cf5356796d84f783baffebf28808c4ed2
diff --git a/source/analysis/test/integration/annotationTest.ml b/source/analysis/test/integration/annotationTest.ml
@@ -765,6 +765,18 @@ let test_check_immutable_annotations context =
           return constant
         return 0
     |}
+    [];
+  assert_type_errors
+    {|
+      import typing
+      constant: typing.Optional[int]
+      def call() -> None: pass
+      def foo() -> int:
+        if constant is not None:
+          call()
+          return constant
+        return 0
+    |}
     ["Incompatible return type [7]: Expected `int` but got `typing.Optional[int]`."];
   assert_type_errors
     {|
@@ -1190,6 +1202,20 @@ let test_check_refinement context =
               else:
                   return 1
     |}
+    [];
+  assert_type_errors
+    {|
+      import typing
+      def call() -> None: pass
+      class A:
+          a: typing.Optional[int] = None
+          def bar(self) -> int:
+              if self.a is not None:
+                  call()
+                  return self.a
+              else:
+                  return 1
+    |}
     ["Incompatible return type [7]: Expected `int` but got `typing.Optional[int]`."];
   assert_type_errors
     {|
diff --git a/source/analysis/test/integration/attributeTest.ml b/source/analysis/test/integration/attributeTest.ml
@@ -312,7 +312,6 @@ let test_check_attributes context =
     [
       "Uninitialized attribute [13]: Attribute `bar` is declared in class `Foo` "
       ^ "to have type `typing.Optional[int]` but is never initialized.";
-      "Incompatible return type [7]: Expected `int` but got `typing.Optional[int]`.";
     ];
   assert_type_errors
     {|
diff --git a/source/analysis/test/integration/globalTest.ml b/source/analysis/test/integration/globalTest.ml
@@ -350,6 +350,18 @@ let test_check_globals context =
           return GLOBAL
         return 0
     |}
+    [];
+  assert_type_errors
+    {|
+      import typing
+      GLOBAL: typing.Optional[int]
+      def call() -> None: pass
+      def foo() -> int:
+        if GLOBAL:
+          call()
+          return GLOBAL
+        return 0
+    |}
     ["Incompatible return type [7]: Expected `int` but got `typing.Optional[int]`."];
   assert_type_errors
     {|
diff --git a/source/analysis/test/integration/isinstanceTest.ml b/source/analysis/test/integration/isinstanceTest.ml
@@ -29,6 +29,19 @@ let test_check_isinstance context =
         if isinstance(MY_GLOBAL, str):
           reveal_type(MY_GLOBAL)
     |}
+    ["Revealed type [-1]: Revealed type for `MY_GLOBAL` is `str`."];
+  assert_type_errors
+    {|
+      import typing
+      MY_GLOBAL: typing.Union[int, str] = 1
+
+      def call() -> None: pass
+
+      def foo() -> None:
+        if isinstance(MY_GLOBAL, str):
+          call()
+          reveal_type(MY_GLOBAL)
+    |}
     ["Revealed type [-1]: Revealed type for `MY_GLOBAL` is `typing.Union[int, str]`."];
   assert_type_errors
     {|
@@ -41,6 +54,21 @@ let test_check_isinstance context =
         if isinstance(f.x, str):
           reveal_type(f.x)
     |}
+    ["Revealed type [-1]: Revealed type for `f.x` is `str`."];
+  assert_type_errors
+    {|
+      import typing
+      class Foo:
+        def __init__(self) -> None:
+          self.x: typing.Union[int, str] = 1
+
+      def call() -> None: pass
+
+      def foo(f: Foo) -> None:
+        if isinstance(f.x, str):
+          call()
+          reveal_type(f.x)
+    |}
     ["Revealed type [-1]: Revealed type for `f.x` is `typing.Union[int, str]`."];
   assert_default_type_errors
     {|
diff --git a/source/analysis/test/integration/refinementTest.ml b/source/analysis/test/integration/refinementTest.ml
@@ -146,17 +146,22 @@ let test_assert_is_none context =
     {|
       from dataclasses import dataclass
       from typing import Optional, Final
+
       class NormalClass():
         x: Optional[int] = None
+
       class ClassWithFinalAttribute():
         def __init__(self, x: Optional[int]) -> None:
           self.x: Final[Optional[int]] = x
+
       @dataclass
       class UnfrozenDataClass():
         x: Optional[int]
+
       @dataclass(frozen=True)
       class FrozenDataClass():
         x: Optional[int]
+
       class ReadOnlyPropertyClass():
         state: bool = True
         @property
@@ -166,12 +171,14 @@ let test_assert_is_none context =
             return None
           else:
             return 8
+
       def foo() -> None:
         normal_class: Final[NormalClass]
         class_with_final_attribute: Final[ClassWithFinalAttribute]
         unfrozen_dataclass: Final[UnfrozenDataClass]
         frozen_dataclass: Final[FrozenDataClass]
         read_only_property_class: Final[ReadOnlyPropertyClass]
+
         if normal_class.x is not None:
           reveal_type(normal_class.x)
         if class_with_final_attribute.x is not None:
@@ -184,30 +191,36 @@ let test_assert_is_none context =
           reveal_type(read_only_property_class.x)
     |}
     [
-      "Revealed type [-1]: Revealed type for `normal_class.x` is `Optional[int]`.";
+      "Revealed type [-1]: Revealed type for `normal_class.x` is `Optional[int]` (inferred: `int`).";
       "Revealed type [-1]: Revealed type for `class_with_final_attribute.x` is `Optional[int]` \
        (inferred: `int`, final).";
-      "Revealed type [-1]: Revealed type for `unfrozen_dataclass.x` is `Optional[int]`.";
+      "Revealed type [-1]: Revealed type for `unfrozen_dataclass.x` is `Optional[int]` (inferred: \
+       `int`).";
       "Revealed type [-1]: Revealed type for `frozen_dataclass.x` is `Optional[int]` (inferred: \
        `int`, final).";
       "Revealed type [-1]: Revealed type for `read_only_property_class.x` is `Optional[int]` \
-       (final).";
+       (inferred: `int`, final).";
     ];
   assert_type_errors
     {|
       from dataclasses import dataclass
       from typing import Optional, Final
+
       class NormalClass():
         x: Optional[int] = None
+
       class ClassWithFinalAttribute():
         def __init__(self, x: Optional[int]) -> None:
           self.x: Final[Optional[int]] = x
+
       @dataclass
       class UnfrozenDataClass():
         x: Optional[int]
+
       @dataclass(frozen=True)
       class FrozenDataClass():
         x: Optional[int]
+
       class ReadOnlyPropertyClass():
         state: bool = True
         @property
@@ -217,21 +230,29 @@ let test_assert_is_none context =
             return None
           else:
             return 8
+
+      def interleaving_call() -> None: pass
+
       def foo() -> None:
         normal_class: Final[NormalClass] = ...
         class_with_final_attribute: Final[ClassWithFinalAttribute] = ...
         unfrozen_dataclass: Final[UnfrozenDataClass] = ...
         frozen_dataclass: Final[FrozenDataClass] = ...
         read_only_property_class: Final[ReadOnlyPropertyClass] = ...
         if normal_class.x is None:
+          interleaving_call()
           reveal_type(normal_class.x)
         if class_with_final_attribute.x is None:
+          interleaving_call()
           reveal_type(class_with_final_attribute.x)
         if unfrozen_dataclass.x is None:
+          interleaving_call()
           reveal_type(unfrozen_dataclass.x)
         if frozen_dataclass.x is None:
+          interleaving_call()
           reveal_type(frozen_dataclass.x)
         if read_only_property_class.x is None:
+          interleaving_call()
           reveal_type(read_only_property_class.x)
     |}
     [
@@ -246,17 +267,22 @@ let test_assert_is_none context =
     {|
       from dataclasses import dataclass
       from typing import Optional, Final
+
       class NormalClass():
         x: float = 3.14
+
       class ClassWithFinalAttribute():
         def __init__(self, x: float) -> None:
           self.x: Final[float] = x
+
       @dataclass
       class UnfrozenDataClass():
         x: float
+
       @dataclass(frozen=True)
       class FrozenDataClass():
         x: float
+
       class ReadOnlyPropertyClass():
         state: bool = True
         @property
@@ -266,21 +292,29 @@ let test_assert_is_none context =
             return 8.2
           else:
             return 8
+
+      def interleaving_call() -> None: pass
+
       def foo() -> None:
         normal_class: Final[NormalClass] = ...
         class_with_final_attribute: Final[ClassWithFinalAttribute] = ...
         unfrozen_dataclass: Final[UnfrozenDataClass] = ...
         frozen_dataclass: Final[FrozenDataClass] = ...
         read_only_property_class: Final[ReadOnlyPropertyClass] = ...
         if isinstance(normal_class.x, int):
+          interleaving_call()
           reveal_type(normal_class.x)
         if isinstance(class_with_final_attribute.x, int):
+          interleaving_call()
           reveal_type(class_with_final_attribute.x)
         if isinstance(unfrozen_dataclass.x, int):
+          interleaving_call()
           reveal_type(unfrozen_dataclass.x)
         if isinstance(frozen_dataclass.x, int):
+          interleaving_call()
           reveal_type(frozen_dataclass.x)
         if isinstance(read_only_property_class.x, int):
+          interleaving_call()
           reveal_type(read_only_property_class.x)
     |}
     [
@@ -294,21 +328,29 @@ let test_assert_is_none context =
     {|
       from dataclasses import dataclass
       from typing import Optional, Final
+
       @dataclass(frozen=True)
       class InnerFrozenDataClass():
         x: Optional[int]
+
       @dataclass(frozen=True)
       class FrozenDataClass():
         inner: InnerFrozenDataClass
+
       @dataclass
       class UnfrozenDataClass():
         inner: InnerFrozenDataClass
+
+      def interleaving_call() -> None: pass
+
       def foo() -> None:
         unfrozen_dataclass: Final[UnfrozenDataClass] = ...
         frozen_dataclass: Final[FrozenDataClass] = ...
         if unfrozen_dataclass.inner.x is not None:
+          interleaving_call()
           reveal_type(unfrozen_dataclass.inner.x)
         if frozen_dataclass.inner.x is not None:
+          interleaving_call()
           reveal_type(frozen_dataclass.inner.x)
     |}
     [
@@ -344,12 +386,20 @@ let test_check_global_refinement context =
         def __init__(self, x: typing.Optional[int]) -> None:
           self.x = x
 
+      def call() -> None: pass
+
       def foo() -> None:
         a = A(3)
         if a.x:
           reveal_type(a.x)
+        if a.x:
+          call()
+          reveal_type(a.x)
     |}
-    ["Revealed type [-1]: Revealed type for `a.x` is `typing.Optional[int]`."];
+    [
+      "Revealed type [-1]: Revealed type for `a.x` is `typing.Optional[int]` (inferred: `int`).";
+      "Revealed type [-1]: Revealed type for `a.x` is `typing.Optional[int]`.";
+    ];
   assert_type_errors
     {|
       import typing
@@ -364,31 +414,44 @@ let test_check_global_refinement context =
           self.assertIsNotNone(a.x)
           reveal_type(a.x)
     |}
-    ["Revealed type [-1]: Revealed type for `a.x` is `typing.Optional[int]`."];
+    ["Revealed type [-1]: Revealed type for `a.x` is `typing.Optional[int]` (inferred: `int`)."];
   assert_type_errors
     {|
       import typing
       MY_GLOBAL: typing.Optional[int] = 1
 
+      def call() -> None: pass
+
       def foo() -> None:
         if MY_GLOBAL:
           reveal_type(MY_GLOBAL)
+          call()
+          reveal_type(MY_GLOBAL)
     |}
-    ["Revealed type [-1]: Revealed type for `MY_GLOBAL` is `typing.Optional[int]`."];
+    [
+      "Revealed type [-1]: Revealed type for `MY_GLOBAL` is `typing.Optional[int]` (inferred: \
+       `int`).";
+      "Revealed type [-1]: Revealed type for `MY_GLOBAL` is `typing.Optional[int]`.";
+    ];
   assert_type_errors
     {|
       import typing
       x: typing.Optional[int] = 1
 
+      def call() -> None: pass
+
       def foo() -> None:
         global x
         x = 1
         if x is not None:
           reveal_type(x)
+          call()
+          reveal_type(x)
     |}
     [
       "Revealed type [-1]: Revealed type for `x` is `typing.Optional[int]` (inferred: \
        `typing_extensions.Literal[1]`).";
+      "Revealed type [-1]: Revealed type for `x` is `typing.Optional[int]`.";
     ]
 
 
@@ -801,6 +864,10 @@ let test_check_final_attribute_refinement context =
       def foo(a: Actor) -> None:
         if a.name is not None:
           expects_str(a.name)
+
+        if a.name is not None:
+          expects_str("unrelated call")
+          expects_str(a.name)
     |}
     [
       "Incompatible parameter type [6]: Expected `str` for 1st positional only parameter to call \
diff --git a/source/analysis/typeCheck.ml b/source/analysis/typeCheck.ml

Original file line number	Diff line number	Diff line change
`@@ -312,7 +312,6 @@ let test_check_attributes context =`
`312`	`312`	`[`
`313`	`313`	"Uninitialized attribute [13]: Attribute `bar` is declared in class `Foo` "
`314`	`314`	^ "to have type `typing.Optional[int]` but is never initialized.";
`315`		- "Incompatible return type [7]: Expected `int` but got `typing.Optional[int]`.";
`316`	`315`	`];`
`317`	`316`	`assert_type_errors`
`318`	`317`	`{\|`