fprime-fpp-python 3.3.14__tar.gz → 3.3.15__tar.gz

{fprime_fpp_python-3.3.14 → fprime_fpp_python-3.3.15}/Cargo.lock

@@ -352,7 +352,7 @@ dependencies = [
 
 [[package]]
 name = "fpp"
-version = "3.3.14"
+version = "3.3.15"
 dependencies = [
  "fpp_analysis",
  "fpp_core",
@@ -363,7 +363,7 @@ dependencies = [
 
 [[package]]
 name = "fpp_analysis"
-version = "3.3.14"
+version = "3.3.15"
 dependencies = [
  "fpp_ast",
  "fpp_core",
@@ -378,7 +378,7 @@ dependencies = [
 
 [[package]]
 name = "fpp_ast"
-version = "3.3.14"
+version = "3.3.15"
 dependencies = [
  "fpp_core",
  "fpp_macros",
@@ -386,7 +386,7 @@ dependencies = [
 
 [[package]]
 name = "fpp_core"
-version = "3.3.14"
+version = "3.3.15"
 dependencies = [
  "line-index",
  "rustc-hash 2.1.1",
@@ -395,7 +395,7 @@ dependencies = [
 
 [[package]]
 name = "fpp_diagram"
-version = "3.3.14"
+version = "3.3.15"
 dependencies = [
  "clap",
  "fpp_analysis",
@@ -412,7 +412,7 @@ dependencies = [
 
 [[package]]
 name = "fpp_errors"
-version = "3.3.14"
+version = "3.3.15"
 dependencies = [
  "annotate-snippets",
  "anstream",
@@ -421,7 +421,7 @@ dependencies = [
 
 [[package]]
 name = "fpp_format"
-version = "3.3.14"
+version = "3.3.15"
 dependencies = [
  "clap",
  "fpp_lsp_parser",
@@ -430,14 +430,14 @@ dependencies = [
 
 [[package]]
 name = "fpp_fs"
-version = "3.3.14"
+version = "3.3.15"
 dependencies = [
  "fpp_core",
 ]
 
 [[package]]
 name = "fpp_lexer"
-version = "3.3.14"
+version = "3.3.15"
 dependencies = [
  "memchr",
  "pretty_assertions",
@@ -446,7 +446,7 @@ dependencies = [
 
 [[package]]
 name = "fpp_lsp_parser"
-version = "3.3.14"
+version = "3.3.15"
 dependencies = [
  "drop_bomb",
  "fpp_lexer",
@@ -456,7 +456,7 @@ dependencies = [
 
 [[package]]
 name = "fpp_lsp_server"
-version = "3.3.14"
+version = "3.3.15"
 dependencies = [
  "anyhow",
  "clap",
@@ -485,7 +485,7 @@ dependencies = [
 
 [[package]]
 name = "fpp_macros"
-version = "3.3.14"
+version = "3.3.15"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -495,7 +495,7 @@ dependencies = [
 
 [[package]]
 name = "fpp_parser"
-version = "3.3.14"
+version = "3.3.15"
 dependencies = [
  "fpp_ast",
  "fpp_core",
@@ -508,7 +508,7 @@ dependencies = [
 
 [[package]]
 name = "fpp_python"
-version = "3.3.14"
+version = "3.3.15"
 dependencies = [
  "fpp_analysis",
  "fpp_ast",
@@ -523,7 +523,7 @@ dependencies = [
 
 [[package]]
 name = "fpp_python_bindgen"
-version = "3.3.14"
+version = "3.3.15"
 dependencies = [
  "rustdoc-json",
  "rustdoc-types",
@@ -533,7 +533,7 @@ dependencies = [
 
 [[package]]
 name = "fpp_python_macros"
-version = "3.3.14"
+version = "3.3.15"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -542,7 +542,7 @@ dependencies = [
 
 [[package]]
 name = "fpp_util"
-version = "3.3.14"
+version = "3.3.15"
 
 [[package]]
 name = "getopts"

{fprime_fpp_python-3.3.14 → fprime_fpp_python-3.3.15}/Cargo.toml

@@ -4,7 +4,7 @@ members = ["fpp_analysis", "fpp_ast", "fpp_core", "fpp_errors", "fpp_fs", "fpp_l
 resolver = "2"
 
 [workspace.package]
-version = "3.3.14"
+version = "3.3.15"
 edition = "2024"
 authors = ["Andrei Tumbar"]
 license = "Apache-2.0"

fprime_fpp_python-3.3.15/PKG-INFO

@@ -0,0 +1,131 @@
+Metadata-Version: 2.4
+Name: fprime-fpp-python
+Version: 3.3.15
+Classifier: Programming Language :: Rust
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Compilers
+Classifier: License :: OSI Approved :: Apache Software License
+Summary: Native FPP bindings — a navigable Python object model over the Rust FPP compiler
+Keywords: fprime,fpp,nasa,flight,software
+Author-email: Andrei Tumbar <andrei.tumbar@jpl.nasa.gov>
+License: Apache-2.0
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+Project-URL: Homepage, https://github.com/fprime-community/fpp-tools
+Project-URL: Repository, https://github.com/fprime-community/fpp-tools
+
+# fprime-fpp-python
+
+Native Python bindings to the [FPP](https://nasa.github.io/fpp/) compiler.
+Installed as `fprime-fpp-python`, imported as `fpp`.
+
+The extension binds directly to the Rust FPP compiler via PyO3.
+
+## Installation
+
+```sh
+pip install fprime-fpp-python
+```
+
+An `abi3` wheel, usable on CPython ≥ 3.10. Building from source needs Rust ≥ 1.85
+and [maturin](https://www.maturin.rs/).
+
+## Usage
+
+```python
+import fpp
+
+model = fpp.analyze(source="""
+module M {
+  array Arr = [4] U32
+  constant answer = 6 * 7
+}
+""")
+
+model.has_errors                             # False
+for d in model.diagnostics:
+    print(d.display)                         # 'path:line:col: error: message'
+
+(unit,) = model.ast                          # one translation unit per input
+(module,) = unit.members
+[type(m).__name__ for m in module.members]   # ['DefArray', 'DefConstant']
+
+arr = model.lookup("M.Arr")                                     # SymbolArrayType
+arr.definition.resolved_type.array_size                         # 4
+model.lookup("M.answer").definition.value.resolved_value.value  # 42
+```
+
+All inputs to one call are analyzed together. A bare string is a path, `source=`
+is text, and `imports=` — the counterpart of `fpp-to-cpp -i` — is analyzed the
+same way but is not part of what you asked about:
+
+```python
+model = fpp.analyze(["MyComponent.fpp"], imports=["Fw/Fw.fpp"])
+[u.uri for u in model.ast if u.is_source]    # ['MyComponent.fpp']
+```
+
+`parse` is the fast front end: it stops after `include` resolution, so you get
+syntax and nothing resolved.
+
+```python
+tree = fpp.parse(["A.fpp", "B.fpp"])
+[u.uri for u in tree.units]                  # ['A.fpp', 'B.fpp']
+```
+
+Subclass `NodeVisitor` and override `visit_<type(node).__name__>`. Traversal is
+deep by default: `super()` descends, omitting it prunes.
+
+```python
+class Constants(fpp.NodeVisitor):
+    def __init__(self):
+        self.values = {}
+
+    def visit_DefConstant(self, node):
+        self.values[node.name] = node.value.resolved_value.value
+        super().visit_DefConstant(node)
+
+consts = Constants()
+consts.visit(model)                          # or a SyntaxTree, TransUnit, or node
+consts.values                                # {'answer': 42}
+```
+
+Semantic types are closed unions, so narrow them with `isinstance` or `match`
+rather than a string tag.
+
+```python
+match arr.definition.resolved_type:
+    case fpp.ArrayType() as a:
+        elt = a.anon_array.elt_type
+        isinstance(elt, fpp.PrimitiveIntType) and elt.value == fpp.IntegerKind.U32
+```
+
+`fpp.pyi` is the reference for the rest — every class, getter and return type —
+and the docstrings carry the contracts: `help(fpp.analyze)`, `help(fpp.Model)`,
+`help(fpp.NodeVisitor)`.
+
+## Development
+
+A Cargo workspace member of
+[fpp-tools](https://github.com/fprime-community/fpp-tools). The node wrappers and
+the recording walk are expanded by `fpp_python_macros` from checked-in
+declarations (`src/ast/defs.rs`, `src/sem/defs.rs`); the core (`pipeline`,
+`ir_core`, `lower_core`, `noderef`, `model`, `visitor`, `diagnostics`) is
+hand-written.
+
+Those declarations and `fpp.pyi` are generated and checked in — change the
+generator or the macro, never the file, and re-run `make`. CI fails on drift.
+
+```sh
+maturin develop            # build + install into the active venv
+pytest tests/              # run the tests
+
+make nightly               # one-time: the nightly the bindgen's rustdoc needs
+make                       # regenerate the declarations, then the stub
+make help                  # the individual codegen targets
+```
+
+The bindgen reflects `fpp_analysis` from rustdoc JSON, whose schema is unstable,
+so the nightly is pinned exactly — in `fpp_python_bindgen/nightly-toolchain`
+alongside the `rustdoc-types` pin in its `Cargo.toml`. Bump the two together.
+`FPP_BINDGEN_TOOLCHAIN` overrides the toolchain for a one-off run.
+

fprime_fpp_python-3.3.15/README.md

@@ -0,0 +1,114 @@
+# fprime-fpp-python
+
+Native Python bindings to the [FPP](https://nasa.github.io/fpp/) compiler.
+Installed as `fprime-fpp-python`, imported as `fpp`.
+
+The extension binds directly to the Rust FPP compiler via PyO3.
+
+## Installation
+
+```sh
+pip install fprime-fpp-python
+```
+
+An `abi3` wheel, usable on CPython ≥ 3.10. Building from source needs Rust ≥ 1.85
+and [maturin](https://www.maturin.rs/).
+
+## Usage
+
+```python
+import fpp
+
+model = fpp.analyze(source="""
+module M {
+  array Arr = [4] U32
+  constant answer = 6 * 7
+}
+""")
+
+model.has_errors                             # False
+for d in model.diagnostics:
+    print(d.display)                         # 'path:line:col: error: message'
+
+(unit,) = model.ast                          # one translation unit per input
+(module,) = unit.members
+[type(m).__name__ for m in module.members]   # ['DefArray', 'DefConstant']
+
+arr = model.lookup("M.Arr")                                     # SymbolArrayType
+arr.definition.resolved_type.array_size                         # 4
+model.lookup("M.answer").definition.value.resolved_value.value  # 42
+```
+
+All inputs to one call are analyzed together. A bare string is a path, `source=`
+is text, and `imports=` — the counterpart of `fpp-to-cpp -i` — is analyzed the
+same way but is not part of what you asked about:
+
+```python
+model = fpp.analyze(["MyComponent.fpp"], imports=["Fw/Fw.fpp"])
+[u.uri for u in model.ast if u.is_source]    # ['MyComponent.fpp']
+```
+
+`parse` is the fast front end: it stops after `include` resolution, so you get
+syntax and nothing resolved.
+
+```python
+tree = fpp.parse(["A.fpp", "B.fpp"])
+[u.uri for u in tree.units]                  # ['A.fpp', 'B.fpp']
+```
+
+Subclass `NodeVisitor` and override `visit_<type(node).__name__>`. Traversal is
+deep by default: `super()` descends, omitting it prunes.
+
+```python
+class Constants(fpp.NodeVisitor):
+    def __init__(self):
+        self.values = {}
+
+    def visit_DefConstant(self, node):
+        self.values[node.name] = node.value.resolved_value.value
+        super().visit_DefConstant(node)
+
+consts = Constants()
+consts.visit(model)                          # or a SyntaxTree, TransUnit, or node
+consts.values                                # {'answer': 42}
+```
+
+Semantic types are closed unions, so narrow them with `isinstance` or `match`
+rather than a string tag.
+
+```python
+match arr.definition.resolved_type:
+    case fpp.ArrayType() as a:
+        elt = a.anon_array.elt_type
+        isinstance(elt, fpp.PrimitiveIntType) and elt.value == fpp.IntegerKind.U32
+```
+
+`fpp.pyi` is the reference for the rest — every class, getter and return type —
+and the docstrings carry the contracts: `help(fpp.analyze)`, `help(fpp.Model)`,
+`help(fpp.NodeVisitor)`.
+
+## Development
+
+A Cargo workspace member of
+[fpp-tools](https://github.com/fprime-community/fpp-tools). The node wrappers and
+the recording walk are expanded by `fpp_python_macros` from checked-in
+declarations (`src/ast/defs.rs`, `src/sem/defs.rs`); the core (`pipeline`,
+`ir_core`, `lower_core`, `noderef`, `model`, `visitor`, `diagnostics`) is
+hand-written.
+
+Those declarations and `fpp.pyi` are generated and checked in — change the
+generator or the macro, never the file, and re-run `make`. CI fails on drift.
+
+```sh
+maturin develop            # build + install into the active venv
+pytest tests/              # run the tests
+
+make nightly               # one-time: the nightly the bindgen's rustdoc needs
+make                       # regenerate the declarations, then the stub
+make help                  # the individual codegen targets
+```
+
+The bindgen reflects `fpp_analysis` from rustdoc JSON, whose schema is unstable,
+so the nightly is pinned exactly — in `fpp_python_bindgen/nightly-toolchain`
+alongside the `rustdoc-types` pin in its `Cargo.toml`. Bump the two together.
+`FPP_BINDGEN_TOOLCHAIN` overrides the toolchain for a one-off run.

{fprime_fpp_python-3.3.14 → fprime_fpp_python-3.3.15}/fpp_analysis/Cargo.toml

@@ -13,11 +13,11 @@ repository.workspace = true
 disabled-tests = []
 
 [dependencies]
-fpp_ast = { path = "../fpp_ast", version = "=3.3.14" }
-fpp_core = { path = "../fpp_core", version = "=3.3.14" }
-fpp_util = { path = "../fpp_util", version = "=3.3.14" }
-fpp_macros = { path = "../fpp_macros", version = "=3.3.14" }
-fpp_parser = { path = "../fpp_parser", version = "=3.3.14" }
+fpp_ast = { path = "../fpp_ast", version = "=3.3.15" }
+fpp_core = { path = "../fpp_core", version = "=3.3.15" }
+fpp_util = { path = "../fpp_util", version = "=3.3.15" }
+fpp_macros = { path = "../fpp_macros", version = "=3.3.15" }
+fpp_parser = { path = "../fpp_parser", version = "=3.3.15" }
 rustc-hash = "2.1.1"
 
 [dev-dependencies]

{fprime_fpp_python-3.3.14 → fprime_fpp_python-3.3.15}/fpp_analysis/src/analysis.rs

@@ -147,7 +147,7 @@ impl Analysis {
             return ty.clone();
         }
         let node_id = fpp_core::Node::new(span);
-        let ty = Arc::new(Type::AbsType(Arc::new(crate::semantics::AbsType {
+        let ty = Arc::new(Type::Abs(Arc::new(crate::semantics::AbsType {
             node: Arc::new(fpp_ast::DefAbsType {
                 node_id,
                 name: fpp_ast::Name {

{fprime_fpp_python-3.3.14 → fprime_fpp_python-3.3.15}/fpp_analysis/src/passes/check_dictionary_defs.rs

@@ -91,7 +91,7 @@ impl<'ast> Visitor<'ast> for CheckDictionaryDefs {
     fn visit_def_array(&self, a: &mut Analysis, node: &'ast DefArray) -> ControlFlow<Self::Break> {
         Self::check_type_def(
             a,
-            Symbol::Array(Arc::new(node.clone())),
+            Symbol::ArrayType(Arc::new(node.clone())),
             node.node_id,
             node.span(),
         );
@@ -101,7 +101,7 @@ impl<'ast> Visitor<'ast> for CheckDictionaryDefs {
     fn visit_def_enum(&self, a: &mut Analysis, node: &'ast DefEnum) -> ControlFlow<Self::Break> {
         Self::check_type_def(
             a,
-            Symbol::Enum(Arc::new(node.clone())),
+            Symbol::EnumType(Arc::new(node.clone())),
             node.node_id,
             node.span(),
         );
@@ -115,7 +115,7 @@ impl<'ast> Visitor<'ast> for CheckDictionaryDefs {
     ) -> ControlFlow<Self::Break> {
         Self::check_type_def(
             a,
-            Symbol::Struct(Arc::new(node.clone())),
+            Symbol::StructType(Arc::new(node.clone())),
             node.node_id,
             node.span(),
         );

{fprime_fpp_python-3.3.14 → fprime_fpp_python-3.3.15}/fpp_analysis/src/passes/check_framework_defs.rs

@@ -231,12 +231,12 @@ impl<'ast> Visitor<'ast> for CheckFrameworkDefs {
         a: &mut Self::State,
         node: &'ast DefArray,
     ) -> ControlFlow<Self::Break> {
-        self.analyze_type(a, Symbol::Array(Arc::new(node.clone())), node.span());
+        self.analyze_type(a, Symbol::ArrayType(Arc::new(node.clone())), node.span());
         ControlFlow::Continue(())
     }
 
     fn visit_def_enum(&self, a: &mut Self::State, node: &'ast DefEnum) -> ControlFlow<Self::Break> {
-        self.analyze_type(a, Symbol::Enum(Arc::new(node.clone())), node.span());
+        self.analyze_type(a, Symbol::EnumType(Arc::new(node.clone())), node.span());
         ControlFlow::Continue(())
     }
 
@@ -245,7 +245,7 @@ impl<'ast> Visitor<'ast> for CheckFrameworkDefs {
         a: &mut Self::State,
         node: &'ast DefStruct,
     ) -> ControlFlow<Self::Break> {
-        self.analyze_type(a, Symbol::Struct(Arc::new(node.clone())), node.span());
+        self.analyze_type(a, Symbol::StructType(Arc::new(node.clone())), node.span());
         ControlFlow::Continue(())
     }
 

{fprime_fpp_python-3.3.14 → fprime_fpp_python-3.3.15}/fpp_analysis/src/passes/check_type_uses.rs

@@ -53,7 +53,7 @@ impl<'ast> Visitor<'ast> for CheckTypeUses<'ast> {
 
         a.type_map.insert(
             node.node_id,
-            Arc::new(Type::AbsType(Arc::new(AbsType {
+            Arc::new(Type::Abs(Arc::new(AbsType {
                 node: a.interned_def(node),
             }))),
         );
@@ -75,7 +75,7 @@ impl<'ast> Visitor<'ast> for CheckTypeUses<'ast> {
         let alias_type = a.type_map.get(&node.type_name.node_id).unwrap().clone();
         a.type_map.insert(
             node.node_id,
-            Arc::new(Type::AliasType(AliasType {
+            Arc::new(Type::Alias(AliasType {
                 node: a.interned_def(node),
                 alias_type,
             })),
@@ -266,9 +266,9 @@ impl<'ast> UseAnalysisPass<'ast, Analysis> for CheckTypeUses<'ast> {
         match &symbol {
             Symbol::AbsType(def) => def.visit(a, self)?,
             Symbol::AliasType(def) => def.visit(a, self)?,
-            Symbol::Array(def) => def.visit(a, self)?,
-            Symbol::Enum(def) => def.visit(a, self)?,
-            Symbol::Struct(def) => def.visit(a, self)?,
+            Symbol::ArrayType(def) => def.visit(a, self)?,
+            Symbol::EnumType(def) => def.visit(a, self)?,
+            Symbol::StructType(def) => def.visit(a, self)?,
             _ => {
                 SemanticError::InvalidSymbol {
                     symbol_name: symbol.name().data.clone(),

{fprime_fpp_python-3.3.14 → fprime_fpp_python-3.3.15}/fpp_analysis/src/passes/check_use_def_cycles.rs

@@ -29,12 +29,12 @@ impl<'ast> CheckUseDefCycles<'ast> {
     fn visit_def_pre(&self, a: &mut Analysis, symbol: Symbol) -> ControlFlow<()> {
         match symbol {
             Symbol::AliasType(node) => node.visit(a, self),
-            Symbol::Array(node) => node.visit(a, self),
+            Symbol::ArrayType(node) => node.visit(a, self),
             Symbol::Constant(node) => node.visit(a, self),
-            Symbol::Enum(node) => node.visit(a, self),
+            Symbol::EnumType(node) => node.visit(a, self),
             Symbol::EnumConstant(node) => node.visit(a, self),
             Symbol::Interface(node) => node.visit(a, self),
-            Symbol::Struct(node) => node.visit(a, self),
+            Symbol::StructType(node) => node.visit(a, self),
             Symbol::Topology(node) => node.visit(a, self),
             _ => ControlFlow::Continue(()),
         }

{fprime_fpp_python-3.3.14 → fprime_fpp_python-3.3.15}/fpp_analysis/src/passes/enter_symbols.rs

@@ -69,7 +69,7 @@ impl<'ast> Visitor<'ast> for EnterSymbols {
     }
 
     fn visit_def_array(&self, a: &mut Analysis, def: &'ast DefArray) -> ControlFlow<Self::Break> {
-        let symbol = Symbol::Array(Arc::new(def.clone()));
+        let symbol = Symbol::ArrayType(Arc::new(def.clone()));
         a.symbol_map.insert(def.node_id, symbol.clone());
         self.enter_symbol(a, symbol, NameGroup::Type)
             .unwrap_or_else(|err| err.emit());
@@ -131,7 +131,7 @@ impl<'ast> Visitor<'ast> for EnterSymbols {
     }
 
     fn visit_def_enum(&self, a: &mut Analysis, def: &'ast DefEnum) -> ControlFlow<Self::Break> {
-        let symbol = Symbol::Enum(Arc::new(def.clone()));
+        let symbol = Symbol::EnumType(Arc::new(def.clone()));
         a.symbol_map.insert(def.node_id, symbol.clone());
 
         (|| -> SemanticResult {
@@ -268,7 +268,7 @@ impl<'ast> Visitor<'ast> for EnterSymbols {
     }
 
     fn visit_def_struct(&self, a: &mut Analysis, def: &'ast DefStruct) -> ControlFlow<Self::Break> {
-        let symbol = Symbol::Struct(Arc::new(def.clone()));
+        let symbol = Symbol::StructType(Arc::new(def.clone()));
         a.symbol_map.insert(def.node_id, symbol.clone());
         self.enter_symbol(a, symbol, NameGroup::Type)
             .unwrap_or_else(|err| err.emit());

{fprime_fpp_python-3.3.14 → fprime_fpp_python-3.3.15}/fpp_analysis/src/passes/eval_constant_exprs.rs

@@ -82,7 +82,7 @@ impl<'ast> EvalConstantExprs<'ast> {
     fn finalize_type(&self, a: &mut Analysis, ty: &Arc<Type>) -> ControlFlow<()> {
         let finalize_defs = FinalizeTypeDefs::new();
         match ty.deref() {
-            Type::AliasType(alias) => {
+            Type::Alias(alias) => {
                 let def = alias.node.clone();
                 self.visit_def_alias_type(a, &def)?;
                 finalize_defs.visit_def_alias_type(a, &def)?;

{fprime_fpp_python-3.3.14 → fprime_fpp_python-3.3.15}/fpp_analysis/src/passes/finalize_type_defs.rs

@@ -62,9 +62,9 @@ impl<'ast> FinalizeTypeDefs<'ast> {
                     match &symbol {
                         Symbol::AbsType(ty) => self.visit_def_abs_type(a, ty.deref()),
                         Symbol::AliasType(ty) => self.visit_def_alias_type(a, ty.deref()),
-                        Symbol::Array(ty) => self.visit_def_array(a, ty.deref()),
-                        Symbol::Enum(ty) => self.visit_def_enum(a, ty.deref()),
-                        Symbol::Struct(ty) => self.visit_def_struct(a, ty.deref()),
+                        Symbol::ArrayType(ty) => self.visit_def_array(a, ty.deref()),
+                        Symbol::EnumType(ty) => self.visit_def_enum(a, ty.deref()),
+                        Symbol::StructType(ty) => self.visit_def_struct(a, ty.deref()),
                         _ => ControlFlow::Continue(()),
                     }?;
 
@@ -133,6 +133,13 @@ impl<'ast> Visitor<'ast> for FinalizeTypeDefs<'ast> {
         ControlFlow::Continue(())
     }
 
+    fn visit_type_name(&self, a: &mut Self::State, node: &'ast TypeName) -> ControlFlow<()> {
+        if matches!(node.kind, TypeNameKind::String(_)) {
+            self.ty(a, node)?;
+        }
+        ControlFlow::Continue(())
+    }
+
     fn visit_trans_unit(
         &self,
         a: &mut Self::State,
@@ -161,7 +168,7 @@ impl<'ast> Visitor<'ast> for FinalizeTypeDefs<'ast> {
         // Update the alias type in the type map
         a.type_map.insert(
             node.node_id,
-            Arc::new(Type::AliasType(AliasType {
+            Arc::new(Type::Alias(AliasType {
                 node: def,
                 alias_type: ty,
             })),

{fprime_fpp_python-3.3.14 → fprime_fpp_python-3.3.15}/fpp_analysis/src/semantics/interned_def.rs

@@ -24,9 +24,9 @@ macro_rules! impl_interned_def {
 impl_interned_def! {
     DefAbsType => AbsType,
     DefAliasType => AliasType,
-    DefArray => Array,
-    DefEnum => Enum,
-    DefStruct => Struct,
+    DefArray => ArrayType,
+    DefEnum => EnumType,
+    DefStruct => StructType,
 }
 
 impl Analysis {