parser: Log warning if source_constant used but no constants defined

Author: i80and

parser/snooty/flutter.py

@@ -1,9 +1,12 @@
 import collections.abc
+import dataclasses
 import typing
-from typing import cast, Any, Callable, Dict, Tuple, Type, TypeVar, Optional, Union
+from typing import cast, Any, Callable, Dict, Set, Tuple, Type, TypeVar, Optional, Union  # noqa
 from typing_extensions import Protocol
 
-CACHED_TYPES: Dict[type, Optional[Dict[str, type]]] = {}
+# As of Python 3.7, the mypy Field definition is different from Python's version.
+# Use an old-fashioned comment until this situation is fixed.
+CACHED_TYPES = {}  # type: Dict[type, Optional[Dict[str, dataclasses.Field[Any]]]]
 
 
 class HasAnnotations(Protocol):
@@ -75,6 +78,9 @@ def inner(ty: type, plural: bool, level: int) -> str:
         if ty is type(None):  # noqa
             return 'nothing'
 
+        if ty is object or ty is Any:
+            return 'anything'
+
         level += 1
         if level > 4:
             # Making nested English clauses understandable is hard. Give up.
@@ -171,22 +177,34 @@ def check_type(ty: Type[C], data: object, ty_module: str = '') -> C:
     if isinstance(data, dict) and ty in CACHED_TYPES:
         annotations = CACHED_TYPES[ty]
         if annotations is None:
-            annotations = typing.get_type_hints(ty)
+            annotations = {field.name: field for field in dataclasses.fields(ty)}
             CACHED_TYPES[ty] = annotations
         result: Dict[str, object] = {}
 
         # Assign missing fields None
+        missing: Set[str] = set()
         for key in annotations:
             if key not in data:
                 data[key] = None
+                missing.add(key)
 
         # Check field types
         for key, value in data.items():
             if key not in annotations:
                 raise LoadUnknownField(ty, data, key)
 
-            expected_type = annotations[key]
-            result[key] = check_type(expected_type, value, ty.__module__)
+            field = annotations[key]
+            have_value = False
+            if key in missing:
+                # Use the field's default_factory if it's defined
+                try:
+                    result[key] = field.default_factory()  # type: ignore
+                    have_value = True
+                except TypeError:
+                    pass
+
+            if not have_value:
+                result[key] = check_type(field.type, value, ty.__module__)
 
         output = ty(**result)
         start_line = getattr(data, '_start_line', None)

parser/snooty/types.py

@@ -122,7 +122,7 @@ def get_id(self) -> PurePath:
 class ProjectConfig:
     root: Path
     name: str
-    constants: Optional[Dict[str, object]] = None
+    constants: Dict[str, object] = field(default_factory=dict)
 
     @classmethod
     def open(cls, root: Path) -> Tuple[Path, 'ProjectConfig', List[Diagnostic]]:
@@ -138,7 +138,7 @@ def open(cls, root: Path) -> Tuple[Path, 'ProjectConfig', List[Diagnostic]]:
                 pass
             path = path.parent
 
-        return root, cls(root, 'untitled', None), []
+        return root, cls(root, 'untitled'), []
 
     def render_constants(self) -> Tuple['ProjectConfig', List[Diagnostic]]:
         if not self.constants:
@@ -155,7 +155,7 @@ def render_constants(self) -> Tuple['ProjectConfig', List[Diagnostic]]:
 
     def read(self, path: Path) -> Tuple[str, List[Diagnostic]]:
         text = path.open().read()
-        return ProjectConfig.substitute(self.constants, text) if self.constants else text, []
+        return ProjectConfig.substitute(self.constants, text)
 
     @staticmethod
     def substitute(constants: Dict[str, object], source: str) -> Tuple[str, List[Diagnostic]]: