Error on re-annotating global identifiers

Summary:
This diff adds illegal annotation target errors when trying to re-annotate an already annotated global.

On master, we already error for a re-annotation of a local:

```
def foo() -> None:
    x: int = 1
    x: str  # error is on this line
    x = ""
    return
```
Illegal annotation target [35]: Target `x` cannot be annotated after it is first declared.

But we don't do this for re-annotation of a global:

```
constant: int = 1

def foo() -> None:
    global constant
    constant: str  # no error
```
And instead relied on the fact that we were special casing out any assignments that touch globals from changing the local annotation map.

In this case, we should be throwing the same error on re-annotation of an already declared global, which would be a lot more user friendly than silently letting the re-annotation pass without actually changing the type, then only erroring if we try to assign a value later.

Reviewed By: grievejia

Differential Revision: D30404490

fbshipit-source-id: 21cb9beb60bb651cb5fa36c6e96a964bfdfa80ed

Author: shannonzhu

source/analysis/test/integration/annotationTest.ml

@@ -743,7 +743,10 @@ let test_check_immutable_annotations context =
         constant: str
         constant = "hi"
     |}
-    [];
+    [
+      "Illegal annotation target [35]: Target `constant` cannot be annotated after it is first \
+       declared.";
+    ];
   assert_type_errors
     {|
       import typing
@@ -815,7 +818,11 @@ let test_check_immutable_annotations context =
           constant: str
         return constant
     |}
-    ["Incompatible return type [7]: Expected `str` but got `int`."];
+    [
+      "Illegal annotation target [35]: Target `constant` cannot be annotated after it is first \
+       declared.";
+      "Incompatible return type [7]: Expected `str` but got `int`.";
+    ];
   assert_type_errors
     {|
       def foo(x: int) -> None:

source/analysis/typeCheck.ml

@@ -4477,10 +4477,10 @@ module State (Context : Context) = struct
                           let check_previously_annotated errors =
                             match name with
                             | Name.Identifier identifier ->
-                                let is_locally_defined =
+                                let is_defined =
                                   Option.is_some
                                     (Resolution.get_local
-                                       ~global_fallback:false
+                                       ~global_fallback:true
                                        ~reference:(Reference.create identifier)
                                        resolution)
                                 in
@@ -4492,7 +4492,8 @@ module State (Context : Context) = struct
                                 in
                                 if
                                   explicit
-                                  && is_locally_defined
+                                  && (not (Define.is_toplevel define))
+                                  && is_defined
                                   && not is_reannotation_with_same_type
                                 then
                                   emit_error