new: Better object constructors

Adding a constructor to each syntactic element that allows you to set all of its parameters in one function call instead of using setter. Quality of life change.
JhnW · Oct 6, 2024 · ae3cc8f · ae3cc8f
1 parent 0cf5178
commit ae3cc8f
Show file tree

Hide file tree

Showing 19 changed files with 818 additions and 30 deletions.
diff --git a/src/devana/syntax_abstraction/classinfo.py b/src/devana/syntax_abstraction/classinfo.py
@@ -1,22 +1,24 @@
 from enum import Enum, auto
 import re
-from typing import Optional, List, Tuple, cast, Any
+from typing import Optional, List, Tuple, cast, Any, Union
 from clang import cindex
-from devana.syntax_abstraction.functioninfo import FunctionInfo
+from devana.syntax_abstraction.functioninfo import FunctionInfo, FunctionModification
 from devana.syntax_abstraction.organizers.codecontainer import CodeContainer
 from devana.syntax_abstraction.codepiece import CodePiece
 from devana.syntax_abstraction.variable import Variable
 from devana.syntax_abstraction.organizers.lexicon import Lexicon
 from devana.syntax_abstraction.templateinfo import TemplateInfo
-from devana.syntax_abstraction.typeexpression import TypeExpression
+from devana.syntax_abstraction.typeexpression import TypeExpression, BasicType
 from devana.syntax_abstraction.comment import Comment
-from devana.syntax_abstraction.attribute import DescriptiveByAttributes
+from devana.syntax_abstraction.attribute import DescriptiveByAttributes, AttributeDeclaration
 from devana.syntax_abstraction._external_source import create_external
 from devana.utility.lazy import LazyNotInit, lazy_invoke
-from devana.utility.traits import IBasicCreatable, ICursorValidate, IFromCursorCreatable
+from devana.utility.init_params import init_params
+from devana.utility.traits import IBasicCreatable, ICursorValidate, IFromCursorCreatable, IFromParamsCreatable
 from devana.configuration import Configuration, ParsingErrorPolicy
 from devana.utility.errors import ParserError
 from devana.syntax_abstraction.syntax import ISyntaxElement
+from devana.code_generation.stubtype import StubType
 
 
 class AccessSpecifier(Enum):
@@ -56,6 +58,14 @@ def from_cursor(cls, cursor: cindex.Cursor, _: Optional = None) -> Optional["Cla
         result = cls(cursor)
         return result
 
+    @classmethod
+    @init_params()
+    def from_params( # pylint: disable=unused-argument
+            cls,
+            access_specifier: Optional[AccessSpecifier] = None
+    ) -> "ClassMember":
+        return cls(None)
+
     @property
     def access_specifier(self) -> AccessSpecifier:
         """Access scope of member."""
@@ -182,6 +192,26 @@ def __init__(self, cursor: Optional[cindex.Cursor] = None, parent: Optional[Code
         else:
             self._type = LazyNotInit
 
+    @classmethod
+    @init_params(skip={"parent"})
+    def from_params( # pylint: disable=unused-argument, arguments-renamed
+            cls,
+            parent: Optional[ISyntaxElement] = None,
+            arguments: Optional[List[FunctionInfo.Argument]] = None,
+            name: Optional[str] = None,
+            return_type: Union[TypeExpression, BasicType, StubType, None] = None,
+            modification: Optional[FunctionModification.ModificationKind] = None,
+            body: Optional[str] = None,
+            namespaces: Optional[List[str]] = None,
+            lexicon: Optional[Lexicon] = None,
+            template: Optional[TemplateInfo] = None,
+            associated_comment: Optional[Comment] = None,
+            prefix: Optional[str] = None,
+            access_specifier: Optional[AccessSpecifier] = None,
+            type: Optional[MethodType] = None,
+    ) -> "MethodInfo":
+        return cls(None, parent)
+
     @property
     @lazy_invoke
     def type(self) -> MethodType:
@@ -261,6 +291,26 @@ def __init__(self, cursor: Optional[cindex.Cursor] = None, parent: Optional[Code
             self._initializer_list = LazyNotInit
             self._name = LazyNotInit
 
+    @classmethod
+    @init_params(skip={"parent"})
+    def from_params( # pylint: disable=unused-argument, arguments-renamed
+            cls,
+            parent: Optional[ISyntaxElement] = None,
+            arguments: Optional[List[FunctionInfo.Argument]] = None,
+            name: Optional[str] = None,
+            modification: Optional[FunctionModification.ModificationKind] = None,
+            body: Optional[str] = None,
+            namespaces: Optional[List[str]] = None,
+            lexicon: Optional[Lexicon] = None,
+            template: Optional[TemplateInfo] = None,
+            associated_comment: Optional[Comment] = None,
+            prefix: Optional[str] = None,
+            access_specifier: Optional[AccessSpecifier] = None,
+            type: Optional[MethodType] = None,
+            initializer_list: Optional[List[InitializerInfo]] = None,
+    ) -> "ConstructorInfo":
+        return cls(None, parent)
+
     @property
     @lazy_invoke
     def initializer_list(self) -> List[InitializerInfo]:
@@ -352,6 +402,24 @@ def __init__(self, cursor: Optional[cindex.Cursor] = None, parent: Optional[Code
         else:
             self._name = LazyNotInit
 
+    @classmethod
+    @init_params(skip={"parent"})
+    def from_params(  # pylint: disable=unused-argument, arguments-differ
+            cls,
+            parent: Optional[ISyntaxElement] = None,
+            arguments: Optional[List[FunctionInfo.Argument]] = None,
+            name: Optional[str] = None,
+            modification: Optional[FunctionModification.ModificationKind] = None,
+            body: Optional[str] = None,
+            namespaces: Optional[List[str]] = None,
+            lexicon: Optional[Lexicon] = None,
+            template: Optional[TemplateInfo] = None,
+            associated_comment: Optional[Comment] = None,
+            prefix: Optional[str] = None,
+            access_specifier: Optional[AccessSpecifier] = None,
+    ) -> "DestructorInfo":
+        return cls(None, parent)
+
     @property
     @lazy_invoke
     def name(self) -> str:
@@ -408,6 +476,21 @@ def from_cursor(cls, cursor: cindex.Cursor, parent: Optional = None) -> Optional
             return cls(cursor, parent)
         return None
 
+    @classmethod
+    @init_params(skip={"parent"})
+    def from_params( # pylint: disable=unused-argument
+            cls,
+            parent: Optional[ISyntaxElement] = None,
+            name: Optional[str] = None,
+            type: Optional[TypeExpression] = None,
+            default_value: Optional[Any] = None,
+            lexicon: Optional[Lexicon] = None,
+            access_specifier: Optional[AccessSpecifier] = None,
+            attributes: Optional[List[AttributeDeclaration]] = None,
+            associated_comment: Optional[Comment] = None
+    ) -> "FieldInfo":
+        return cls(None, parent)
+
     @property
     @lazy_invoke
     def associated_comment(self) -> Optional[Comment]:
@@ -460,6 +543,17 @@ def from_cursor(cls, cursor: cindex.Cursor, parent: Optional = None) -> Optional
             return None
         return cls(cursor, parent)
 
+    @classmethod
+    @init_params(skip={"parent"})
+    def from_params( # pylint: disable=unused-argument
+            cls,
+            parent: Optional[ISyntaxElement] = None,
+            type: Optional[AccessSpecifier] = None,
+            is_unnamed: Optional[bool] = None,
+            content: Optional[List[Any]] = None,
+    ) -> "SectionInfo":
+        return cls(None, parent)
+
     @staticmethod
     def is_cursor_valid(cursor: cindex.Cursor) -> bool:
         return cursor.kind == cindex.CursorKind.CXX_ACCESS_SPEC_DECL
@@ -532,7 +626,7 @@ def __repr__(self):
         return f"{type(self).__name__}:{self.type} ({super().__repr__()})"
 
 
-class InheritanceInfo(IFromCursorCreatable, ISyntaxElement):
+class InheritanceInfo(IFromCursorCreatable, IFromParamsCreatable, ISyntaxElement):
     """Information about class/structure inheritance."""
 
     class InheritanceValue(IBasicCreatable, ISyntaxElement):
@@ -563,6 +657,19 @@ def from_cursor(cls, cursor: cindex.Cursor, parent: Optional = None) -> Optional
                                                                                           ".InheritanceValue")]:
             return cls(cursor, parent)
 
+        @classmethod
+        @init_params(skip={"parent"})
+        def from_params( # pylint: disable=unused-argument
+                cls,
+                parent: Optional[ISyntaxElement] = None,
+                access_specifier: Optional[AccessSpecifier] = None,
+                type: Optional[Any] = None,
+                is_virtual: Optional[bool] = None,
+                template_arguments: Optional[List[TypeExpression]] = None,
+                namespaces: Optional[List[str]] = None,
+        ) -> "InheritanceInfo.InheritanceValue":
+            return cls(None, parent)
+
         @property
         def parent(self) -> CodeContainer:
             """Class parent."""
@@ -667,6 +774,15 @@ def __init__(self, cursor: Optional[cindex.Cursor] = None, parent: Optional = No
     def from_cursor(cls, cursor: cindex.Cursor, parent: Optional = None) -> Optional["InheritanceInfo"]:
         return cls(cursor, parent)
 
+    @classmethod
+    @init_params(skip={"parent"})
+    def from_params( # pylint: disable=unused-argument
+            cls,
+            parent: Optional[ISyntaxElement] = None,
+            type_parents: Optional[List[InheritanceValue]] = None,
+    ) -> "InheritanceInfo":
+        return cls(None, parent)
+
     @property
     @lazy_invoke
     def type_parents(self) -> List[InheritanceValue]:
@@ -776,6 +892,29 @@ def from_cursor(cls, cursor: cindex.Cursor, parent: Optional = None) -> Optional
         except ParserError:
             return None
 
+    @classmethod
+    @init_params(skip={"parent"})
+    def from_params( # pylint: disable=unused-argument
+            cls,
+            parent: Optional[ISyntaxElement] = None,
+            content: Optional[List[Any]] = None,
+            namespace: Optional[str] = None,
+            attributes: Optional[List[AttributeDeclaration]] = None,
+            is_class: Optional[bool] = None,
+            is_struct: Optional[bool] = None,
+            is_final: Optional[bool] = None,
+            name: Optional[str] = None,
+            inheritance: Optional[InheritanceInfo] = None,
+            is_declaration: Optional[bool] = None,
+            is_definition: Optional[bool] = None,
+            namespaces: Optional[List[str]] = None,
+            lexicon: Optional[Lexicon] = None,
+            template: Optional[TemplateInfo] = None,
+            associated_comment: Optional[Comment] = None,
+            prefix: Optional[str] = None
+    ) -> "ClassInfo":
+        return cls(None, parent)
+
     @staticmethod
     def is_cursor_valid(cursor: cindex.Cursor) -> bool:
         if cursor.kind == cindex.CursorKind.STRUCT_DECL:

diff --git a/src/devana/syntax_abstraction/enuminfo.py b/src/devana/syntax_abstraction/enuminfo.py
@@ -6,10 +6,11 @@
 from devana.syntax_abstraction.comment import Comment
 from devana.syntax_abstraction.typeexpression import BasicType
 from devana.syntax_abstraction.organizers.lexicon import Lexicon
-from devana.syntax_abstraction.attribute import DescriptiveByAttributes
+from devana.syntax_abstraction.attribute import DescriptiveByAttributes, AttributeDeclaration
 from devana.utility.errors import ParserError
 from devana.utility.lazy import LazyNotInit, lazy_invoke
 from devana.utility.traits import IBasicCreatable, ICursorValidate
+from devana.utility.init_params import init_params
 from devana.syntax_abstraction.syntax import ISyntaxElement
 
 
@@ -50,6 +51,18 @@ def from_cursor(cls, cursor: cindex.Cursor, parent: Optional = None) -> Optional
                 return None
             return cls(cursor, parent)
 
+        @classmethod
+        @init_params(skip={"parent"})
+        def from_params( # pylint: disable=unused-argument
+                cls,
+                parent: Optional[ISyntaxElement] = None,
+                name: Optional[str] = None,
+                value: Optional[int] = None,
+                is_default: Optional[bool] = None,
+                associated_comment: Optional[Comment] = None,
+        ) -> "EnumInfo.EnumValue":
+            return cls(None, parent)
+
         @staticmethod
         def is_cursor_valid(cursor: cindex.Cursor) -> bool:
             return cursor.kind == cindex.CursorKind.ENUM_CONSTANT_DECL
@@ -144,6 +157,26 @@ def __init__(self, cursor: Optional[cindex.Cursor] = None, parent: Optional[Code
     def is_cursor_valid(cursor: cindex.Cursor) -> bool:
         return cursor.kind == cindex.CursorKind.ENUM_DECL
 
+    @classmethod
+    @init_params(skip={"parent"})
+    def from_params( # pylint: disable=unused-argument
+            cls,
+            parent: Optional[ISyntaxElement] = None,
+            content: Optional[List[Any]] = None,
+            namespace: Optional[str] = None,
+            attributes: Optional[List[AttributeDeclaration]] = None,
+            name: Optional[str] = None,
+            values: Optional[List[EnumValue]] = None,
+            is_scoped: Optional[bool] = None,
+            prefix: Optional[Literal["class", "struct"]] = None,
+            numeric_type: Optional[BasicType] = None,
+            is_declaration: Optional[bool] = None,
+            is_definition: Optional[bool] = None,
+            lexicon: Optional[Lexicon] = None,
+            associated_comment: Optional[Comment] = None,
+    ) -> "EnumInfo":
+        return cls(None, parent)
+
     @property
     @lazy_invoke
     def name(self) -> str:

diff --git a/src/devana/syntax_abstraction/externc.py b/src/devana/syntax_abstraction/externc.py
@@ -1,11 +1,12 @@
-from typing import Optional, List
+from typing import Optional, List, Any
 from clang import cindex
 from devana.syntax_abstraction.organizers.codecontainer import CodeContainer
 from devana.syntax_abstraction.organizers.lexicon import Lexicon
 from devana.syntax_abstraction.functioninfo import FunctionInfo
+from devana.syntax_abstraction.syntax import ISyntaxElement
 from devana.utility.errors import ParserError
 from devana.utility.lazy import lazy_invoke
-from devana.syntax_abstraction.syntax import ISyntaxElement
+from devana.utility.init_params import init_params
 
 
 class ExternC(CodeContainer):
@@ -25,6 +26,18 @@ def __init__(self, cursor: Optional[cindex.Cursor] = None, parent: Optional[Code
         self._namespace = None
         self._lexicon = Lexicon.create(self)
 
+    @classmethod
+    @init_params(skip={"parent"})
+    def from_params( # pylint: disable=unused-argument
+            cls,
+            parent: Optional[ISyntaxElement] = None,
+            content: Optional[List[Any]] = None,
+            namespace: Optional[str] = None,
+            name: Optional[str] = None,
+            lexicon: Optional[Lexicon] = None
+    ):
+        return cls(None, parent)
+
     @staticmethod
     def is_cursor_valid(cursor: cindex.Cursor) -> bool:
         if cursor.kind != cindex.CursorKind.LINKAGE_SPEC:

diff --git a/src/devana/syntax_abstraction/functioninfo.py b/src/devana/syntax_abstraction/functioninfo.py
@@ -1,4 +1,4 @@
-from typing import Optional, Tuple, List, Any
+from typing import Optional, Tuple, List, Any, Union
 from enum import auto, IntFlag
 import re
 from clang import cindex
@@ -14,7 +14,9 @@
 from devana.utility.lazy import LazyNotInit, lazy_invoke
 from devana.utility.traits import IBasicCreatable, ICursorValidate
 from devana.utility.errors import ParserError, CodeError
+from devana.utility.init_params import init_params
 from devana.syntax_abstraction.syntax import ISyntaxElement
+from devana.code_generation.stubtype import StubType
 
 
 class FunctionModification(metaclass=FakeEnum):
@@ -275,6 +277,19 @@ def __init__(self, cursor: Optional[cindex.Cursor] = None, parent: Optional = No
         def is_cursor_valid(cursor: cindex.Cursor) -> bool:
             return cursor.kind == cindex.CursorKind.PARM_DECL
 
+        @classmethod
+        @init_params(skip={"parent"})
+        def from_params( # pylint: disable=unused-argument
+            cls,
+            parent: Optional[ISyntaxElement] = None,
+            name: Optional[str] = None,
+            type: Optional[TypeExpression] = None,
+            default_value: Optional[str] = None,
+            lexicon: Optional[Lexicon] = None,
+            attributes: Optional[List[AttributeDeclaration]] = None
+    ) -> "FunctionInfo.Argument":
+            return cls(None, parent)
+
         @property
         @lazy_invoke
         def attributes(self) -> List[AttributeDeclaration]:
@@ -335,6 +350,25 @@ def from_cursor(cls, cursor: cindex.Cursor, parent: Optional = None) -> Optional
             return cls(cursor, parent)
         return None
 
+    @classmethod
+    @init_params(skip={"parent"})
+    def from_params( # pylint: disable=unused-argument
+            cls,
+            parent: Optional[ISyntaxElement] = None,
+            attributes: Optional[List[AttributeDeclaration]] = None,
+            arguments: Optional[List[Argument]] = None,
+            name: Optional[str] = None,
+            return_type: Union[TypeExpression, BasicType, StubType, None] = None,
+            modification: Optional[FunctionModification.ModificationKind] = None,
+            body: Optional[str] = None,
+            namespaces: Optional[List[str]] = None,
+            lexicon: Optional[Lexicon] = None,
+            template: Optional[TemplateInfo] = None,
+            associated_comment: Optional[Comment] = None,
+            prefix: Optional[str] = None,
+    ) -> "FunctionInfo":
+        return cls(None, parent)
+
     @property
     @lazy_invoke
     def arguments(self) -> List[Argument]: