Implement pyre infer (6/n) -- JSON deserialization of raw infer output

Reviewed By: dkgi

Differential Revision: D30169046

fbshipit-source-id: ba93ed2aa70ff1423858f0740b1ddb7e6efad7d2

Author: grievejia

client/commands/v2/infer.py

@@ -13,6 +13,8 @@
 from pathlib import Path
 from typing import Any, Dict, Iterator, List, Optional, Sequence
 
+import dataclasses_json
+
 from ... import commands, command_arguments, configuration as configuration_module
 from . import remote_logging, backend_arguments, start
 
@@ -110,6 +112,105 @@ def serialize(self) -> Dict[str, Any]:
         }
 
 
+@dataclasses_json.dataclass_json(
+    letter_case=dataclasses_json.LetterCase.CAMEL,
+    undefined=dataclasses_json.Undefined.EXCLUDE,
+)
+@dataclasses.dataclass(frozen=True)
+class RawAnnotationLocation:
+    qualifier: str
+    path: str
+    line: int
+
+
+@dataclasses_json.dataclass_json(
+    letter_case=dataclasses_json.LetterCase.CAMEL,
+    undefined=dataclasses_json.Undefined.EXCLUDE,
+)
+@dataclasses.dataclass(frozen=True)
+class RawGlobalAnnotation:
+    name: str
+    location: RawAnnotationLocation
+    annotation: str
+
+
+@dataclasses_json.dataclass_json(
+    letter_case=dataclasses_json.LetterCase.CAMEL,
+    undefined=dataclasses_json.Undefined.EXCLUDE,
+)
+@dataclasses.dataclass(frozen=True)
+class RawAttributeAnnotation:
+    parent: str
+    name: str
+    location: RawAnnotationLocation
+    annotation: str
+
+
+@dataclasses_json.dataclass_json(
+    letter_case=dataclasses_json.LetterCase.CAMEL,
+    undefined=dataclasses_json.Undefined.EXCLUDE,
+)
+@dataclasses.dataclass(frozen=True)
+class RawParameter:
+    name: str
+    index: int
+    annotation: Optional[str] = None
+    value: Optional[str] = None
+
+
+@dataclasses_json.dataclass_json(
+    letter_case=dataclasses_json.LetterCase.CAMEL,
+    undefined=dataclasses_json.Undefined.EXCLUDE,
+)
+@dataclasses.dataclass(frozen=True)
+class RawDefineAnnotation:
+    name: str
+    location: RawAnnotationLocation
+    parent: Optional[str] = None
+    return_: Optional[str] = dataclasses.field(
+        metadata=dataclasses_json.config(field_name="return"), default=None
+    )
+    parameters: List[RawParameter] = dataclasses.field(default_factory=list)
+    decorators: List[str] = dataclasses.field(default_factory=list)
+    is_async: bool = dataclasses.field(
+        metadata=dataclasses_json.config(field_name="async"), default=False
+    )
+
+
+@dataclasses_json.dataclass_json(
+    letter_case=dataclasses_json.LetterCase.CAMEL,
+    undefined=dataclasses_json.Undefined.EXCLUDE,
+)
+@dataclasses.dataclass(frozen=True)
+class RawInferOutput:
+    global_annotations: List[RawGlobalAnnotation] = dataclasses.field(
+        metadata=dataclasses_json.config(field_name="globals"), default_factory=list
+    )
+    attribute_annotations: List[RawAttributeAnnotation] = dataclasses.field(
+        metadata=dataclasses_json.config(field_name="attributes"), default_factory=list
+    )
+    define_annotations: List[RawDefineAnnotation] = dataclasses.field(
+        metadata=dataclasses_json.config(field_name="defines"), default_factory=list
+    )
+
+    @staticmethod
+    def create(input: str) -> "RawInferOutput":
+        try:
+            # pyre-fixme[16]: Pyre doesn't understand `dataclasses_json`
+            return RawInferOutput.schema().loads(input)
+        except (
+            TypeError,
+            KeyError,
+            ValueError,
+            dataclasses_json.mm.ValidationError,
+        ) as error:
+            raise RawInferOutputParsingError(str(error)) from error
+
+
+class RawInferOutputParsingError(Exception):
+    pass
+
+
 def create_infer_arguments(
     configuration: configuration_module.Configuration,
     infer_arguments: command_arguments.InferArguments,

client/commands/v2/tests/infer_test.py

@@ -3,16 +3,28 @@
 # This source code is licensed under the MIT license found in the
 # LICENSE file in the root directory of this source tree.
 
+import json
 import tempfile
 from pathlib import Path
-from typing import Iterable, Tuple
+from typing import Iterable, Tuple, Dict
 
 import testslide
 
 from .... import configuration, command_arguments
 from ....tests import setup
 from .. import backend_arguments
-from ..infer import Arguments, InferMode, create_infer_arguments
+from ..infer import (
+    Arguments,
+    InferMode,
+    create_infer_arguments,
+    RawAnnotationLocation,
+    RawGlobalAnnotation,
+    RawAttributeAnnotation,
+    RawParameter,
+    RawDefineAnnotation,
+    RawInferOutput,
+    RawInferOutputParsingError,
+)
 
 
 class ArgumentTest(testslide.TestCase):
@@ -184,3 +196,139 @@ def test_create_infer_arguments(self) -> None:
                     ),
                 ),
             )
+
+    def test_parse_raw_infer_output(self) -> None:
+        def assert_parsed(input: Dict[str, object], expected: RawInferOutput) -> None:
+            self.assertEqual(RawInferOutput.create(json.dumps(input)), expected)
+
+        def assert_not_parsed(input: str) -> None:
+            with self.assertRaises(RawInferOutputParsingError):
+                RawInferOutput.create(input)
+
+        assert_not_parsed("")
+        assert_not_parsed("[]")
+        assert_not_parsed("42")
+        assert_not_parsed('"abc"')
+
+        assert_parsed({}, RawInferOutput())
+        assert_parsed({"irrelevant": 42}, RawInferOutput())
+        assert_parsed(
+            {
+                "globals": [
+                    {
+                        "name": "x",
+                        "location": {"qualifier": "test", "path": "test.py", "line": 4},
+                        "annotation": "int",
+                    }
+                ]
+            },
+            RawInferOutput(
+                global_annotations=[
+                    RawGlobalAnnotation(
+                        name="x",
+                        location=RawAnnotationLocation(
+                            qualifier="test", path="test.py", line=4
+                        ),
+                        annotation="int",
+                    )
+                ]
+            ),
+        )
+        assert_parsed(
+            {
+                "attributes": [
+                    {
+                        "parent": "Foo",
+                        "name": "x",
+                        "location": {"qualifier": "test", "path": "test.py", "line": 3},
+                        "annotation": "int",
+                    }
+                ]
+            },
+            RawInferOutput(
+                attribute_annotations=[
+                    RawAttributeAnnotation(
+                        parent="Foo",
+                        name="x",
+                        location=RawAnnotationLocation(
+                            qualifier="test", path="test.py", line=3
+                        ),
+                        annotation="int",
+                    )
+                ]
+            ),
+        )
+        assert_parsed(
+            {
+                "defines": [
+                    {
+                        "name": "test.foo",
+                        "parent": None,
+                        "return": None,
+                        "parameters": [],
+                        "decorators": [],
+                        "location": {"qualifier": "test", "path": "test.py", "line": 1},
+                        "async": False,
+                    }
+                ]
+            },
+            RawInferOutput(
+                define_annotations=[
+                    RawDefineAnnotation(
+                        name="test.foo",
+                        location=RawAnnotationLocation(
+                            qualifier="test", path="test.py", line=1
+                        ),
+                        is_async=False,
+                    )
+                ]
+            ),
+        )
+        assert_parsed(
+            {
+                "defines": [
+                    {
+                        "name": "test.Foo.foo",
+                        "parent": "test.Foo",
+                        "return": "int",
+                        "parameters": [
+                            {
+                                "name": "self",
+                                "annotation": None,
+                                "value": None,
+                                "index": 0,
+                            },
+                            {
+                                "name": "x",
+                                "annotation": "int",
+                                "value": "42",
+                                "index": 1,
+                            },
+                        ],
+                        "decorators": ["derp"],
+                        "location": {"qualifier": "test", "path": "test.py", "line": 1},
+                        "async": True,
+                    }
+                ]
+            },
+            RawInferOutput(
+                define_annotations=[
+                    RawDefineAnnotation(
+                        name="test.Foo.foo",
+                        parent="test.Foo",
+                        location=RawAnnotationLocation(
+                            qualifier="test", path="test.py", line=1
+                        ),
+                        return_="int",
+                        parameters=[
+                            RawParameter(name="self", index=0),
+                            RawParameter(
+                                name="x", index=1, annotation="int", value="42"
+                            ),
+                        ],
+                        decorators=["derp"],
+                        is_async=True,
+                    )
+                ]
+            ),
+        )