diff --git a/CHANGELOG.md b/CHANGELOG.md
index cc16d9a..d851247 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -8,6 +8,12 @@
 - Made GetKnownContexts custom request not wait for analysis results by default, reducing the chances of overfilling workpool capacity while analysises are running.
 - Fix issue where the server would internally format URIs incorrectly in some cases
 - The language server logs will now be in local time of whatever machine they are running on, rather than UTC.
+- Fixed bug in template cycle detection that could cause crashes when an object
+  instantiated a template involved in a cycle
+- Fixed template cycle breaking so it will be deterministic in all cases
+- Added basic type system. Goto definition/declaration and find
+  references will now work on types. Goto type-def will work on simple references
+- Fixed internal error when `vect` modifiers were made inside type declaration
 
 ## 0.9.19
 - Added configuration option to control the max cache size while resolving references in semantic analysis, defaulting to 500MB
diff --git a/src/actions/requests.rs b/src/actions/requests.rs
index 19be68b..f04a7bc 100644
--- a/src/actions/requests.rs
+++ b/src/actions/requests.rs
@@ -14,7 +14,7 @@ use crate::actions::{AnalysisProgressKind, AnalysisWaitKind,
                      ContextDefinition, InitActionContext,
                      rpc_error_code};
 use crate::actions::notifications::ContextDefinitionKindParam;
-use crate::actions::semantic_lookup::{DLSLimitation, declarations_at_fp, definitions_at_fp, implementations_at_fp, references_at_fp};
+use crate::actions::semantic_lookup::{DLSLimitation, declarations_at_fp, definitions_at_fp, implementations_at_fp, references_at_fp, type_definitions_at_fp};
 use crate::analysis::{Named, DeclarationSpan, LocationSpan};
 use crate::analysis::symbols::SimpleSymbol;
 use crate::config::Config;
@@ -31,6 +31,7 @@ pub use crate::lsp_data::request::{
     Formatting,
     GotoDeclaration, GotoDeclarationResponse,
     GotoDefinition,
+    GotoTypeDefinition,
     GotoImplementation, GotoImplementationResponse,
     HoverRequest,
     RangeFormatting,
@@ -570,6 +571,62 @@ impl RequestAction for GotoDefinition {
     }
 }
 
+impl RequestAction for GotoTypeDefinition {
+    type Response = ResponseWithMessage<Option<GotoDefinitionResponse>>;
+
+    fn timeout() -> std::time::Duration {
+        crate::server::dispatch::DEFAULT_REQUEST_TIMEOUT * 5
+    }
+
+    fn fallback_response() -> Result<Self::Response, ResponseError> {
+        Ok(None.into())
+    }
+
+    fn get_identifier(params: &Self::Params) -> String {
+        Self::request_identifier(
+            &text_document_position_to_ident(
+                &params.text_document_position_params))
+    }
+
+    fn handle<O: Output>(
+        ctx: InitActionContext<O>,
+        params: Self::Params,
+    ) -> Result<Self::Response, ResponseError> {
+        debug!("Requesting type definitions with params {:?}", params);
+        let fp = {
+            let maybe_fp = ctx.text_doc_pos_to_pos(
+                &params.text_document_position_params,
+                "goto_type_def");
+            if maybe_fp.is_none() {
+                return Self::fallback_response();
+            }
+            maybe_fp.unwrap()
+        };
+        let canon_path = make_canon_path!(fp.path())?;
+        wait_for_device_path!(ctx, canon_path);
+
+        let mut limitations = HashSet::new();
+        match type_definitions_at_fp(&ctx, &fp, &mut limitations) {
+            Ok(locs) => {
+                let lsp_locations: Vec<_> = locs.into_iter()
+                    .map(|l|ls_util::dls_to_location(&l))
+                    .collect();
+                Ok(response_maybe_with_limitations(
+                    &fp.path(),
+                    Some(GotoDefinitionResponse::Array(lsp_locations)),
+                    limitations,
+                    &ctx))
+            },
+            Err(lookuperror) => {
+                let main_file_name = fp.path();
+                warn_miss_lookup(lookuperror,
+                                 main_file_name.to_str());
+                Self::fallback_response()
+            },
+        }
+    }
+}
+
 impl RequestAction for References {
     type Response = ResponseWithMessage<Vec<Location>>;
 
diff --git a/src/actions/semantic_lookup.rs b/src/actions/semantic_lookup.rs
index 0499b19..1d29494 100644
--- a/src/actions/semantic_lookup.rs
+++ b/src/actions/semantic_lookup.rs
@@ -17,7 +17,7 @@ use crate::analysis::symbols::DMLSymbolKind;
 use crate::analysis::{DeviceAnalysis, IsolatedAnalysis, LocationSpan, SymbolRef, ZeroRange};
 
 use crate::analysis::parsing::tree::{ZeroSpan, ZeroFilePosition};
-use crate::analysis::reference::{CodeReference, Reference, ReferenceKind};
+use crate::analysis::reference::{CodeReference, Reference};
 use crate::file_management::CanonPath;
 use crate::server::Output;
 
@@ -42,14 +42,6 @@ impl fmt::Display for DLSLimitation {
     }
 }
 
-pub fn type_semantic_limitation() -> DLSLimitation {
-    DLSLimitation {
-        issue_num: 65,
-        description: "The DLS does not currently support semantic analysis of \
-                      types, including reference finding".to_string(),
-    }
-}
-
 pub fn isolated_template_limitation(template_name: &str) -> DLSLimitation {
     DLSLimitation {
         issue_num: 31,
@@ -62,10 +54,6 @@ pub fn isolated_template_limitation(template_name: &str) -> DLSLimitation {
     }
 }
 
-// Because symbols need to be tied to their source analysis that result is
-// a [(DeviceAnalysis, [SymbolRef])] list
-// The reference comes from an isolated analysis, and thus is disconnected from a device
-// context
 type DeviceSymbols<'t> = Vec<(&'t DeviceAnalysis, Vec<SymbolRef>)>;
 enum SymbolsOrReference<'t> {
     Symbols(DeviceSymbols<'t>),
@@ -182,32 +170,28 @@ fn get_refs_and_syms_at_fp<'t>(
     -> Result<SymbolsOrReference<'t>, AnalysisLookupError> {
     debug!("Looking up references and symbols at position {:?}", fp);
     let ref_at_pos = analysis_info.isolated_analysis.lookup_reference(fp);
-    
-    let context_sym_at_pos = context_symbol_at_pos(analysis_info.isolated_analysis, fp);
-    let symbols_at_fp = context_sym_at_pos.map(|cs| {
-        analysis_info.device_analysises.iter().map(
-            |a|(*a, match a.lookup_symbols(&cs, relevant_limitations) {
-                Ok(syms) => syms,
-                Err(e) => {
-                    internal_error!("failed to find context symbol at {:?}: {}", fp, e);
-                    vec![]
-                }
-            }))
-        .collect::<Vec<_>>()
-    });
-    if let Some(syms) = symbols_at_fp {
+
+    if let Some(decl) = declaration_at_pos(fp, analysis_info) {
         if ref_at_pos.is_some() {
             error!("Obtained both symbol and reference at {:?}\
                         (reference is {:?}), defaulted to symbol",
             &fp, ref_at_pos);
         }
+        let syms = match decl {
+            PositionDeclaration::Contexted(cs) =>
+                analysis_info.device_analysises.iter().map(
+                    |a|(*a, match a.lookup_symbols(&cs, relevant_limitations) {
+                        Ok(syms) => syms,
+                        Err(e) => {
+                            internal_error!("failed to find context symbol at {:?}: {}", fp, e);
+                            vec![]
+                        }
+                    }))
+                .collect::<Vec<_>>(),
+            PositionDeclaration::TypeMember(syms) => syms,
+        };
         return Ok(SymbolsOrReference::Symbols(syms));
     }
-    if let Some(refr) = ref_at_pos.and_then(|r|r.as_code_ref()) {
-        if refr.reference_kind() == ReferenceKind::Type {
-            relevant_limitations.insert(type_semantic_limitation());
-        }
-    }
     if let Some(refr) = ref_at_pos {
         Ok(SymbolsOrReference::Reference(refr.clone()))
     } else {
@@ -285,6 +269,26 @@ fn context_symbol_at_pos<'t>(isolated_analysis: &'t IsolatedAnalysis, pos: &Zero
     context
 }
 
+enum PositionDeclaration<'t> {
+    Contexted(ContextedSymbol<'t>),
+    TypeMember(DeviceSymbols<'t>),
+}
+
+fn declaration_at_pos<'t>(fp: &ZeroFilePosition, analysis_info: &AnalysisInfo<'t>)
+    -> Option<PositionDeclaration<'t>> {
+    if let Some(cs) = context_symbol_at_pos(analysis_info.isolated_analysis, fp) {
+        return Some(PositionDeclaration::Contexted(cs));
+    }
+    let member_syms: DeviceSymbols<'t> = analysis_info.device_analysises.iter()
+        .map(|a|(*a, a.member_symbol_at_pos(fp, &analysis_info.isolated_analysis.ast)
+                 .into_iter().collect()))
+        .collect();
+    if member_syms.iter().any(|(_, syms)|!syms.is_empty()) {
+        return Some(PositionDeclaration::TypeMember(member_syms));
+    }
+    None
+}
+
 fn symbol_implementations_of_symbol<'t>(symbol: &'t SymbolRef,
                                         analysis: &'t DeviceAnalysis)
     -> Vec<SymbolRef> {
@@ -459,3 +463,77 @@ pub fn references_at_fp(context: &InitActionContext<impl Output>,
        .flat_map(|s|s.lock().unwrap().references.clone())
        .collect())
 }
+
+/// Walk a resolved `DMLType`, peeling pointer/array/vector wrappers and
+/// typedef indirections, and return the span of the outermost
+/// typedef/template-as-type declaration, if any.
+fn outermost_typedef_span(ty: &crate::analysis::templating::types::DMLType)
+    -> Option<ZeroSpan> {
+    use crate::analysis::templating::types::DMLConcreteType;
+    let mut cur = ty.clone();
+    let mut outermost = None;
+    loop {
+        let concrete = cur?;
+        match concrete.as_ref() {
+            DMLConcreteType::Typedef(td) => { outermost.get_or_insert(td.decl_name.span); }
+            DMLConcreteType::Trait(t) => { outermost.get_or_insert(t.decl_name.span); }
+            _ => {}
+        }
+        cur = match concrete.peel_one() {
+            Some(next) => next.clone(),
+            None => return outermost,
+        };
+    }
+}
+
+/// Resolve the `DMLType` referred to by a symbol's source, if any.
+fn resolved_type_from_symbol_source(source: &crate::analysis::symbols::SymbolSource)
+    -> Option<&crate::analysis::templating::types::DMLType> {
+    source.resolved_type()
+}
+
+
+pub fn type_definitions_at_fp(context: &InitActionContext<impl Output>,
+                              fp: &ZeroFilePosition,
+                              relevant_limitations: &mut HashSet<DLSLimitation>)
+    -> Result<Vec<ZeroSpan>, AnalysisLookupError> {
+    let analysis_lock = context.analysis.lock().unwrap();
+    let mut semantic_lookup = SemanticLookup::create_lookup(
+        fp,
+        &analysis_lock,
+        context)?;
+    mem::swap(relevant_limitations, &mut semantic_lookup.recognized_limitations);
+
+    let mut results: Vec<ZeroSpan> = Vec::new();
+    for (_device, symbols) in &semantic_lookup.stored_symbols {
+        for sym in symbols {
+            let (kind, source) = {
+                let lock = sym.lock().unwrap();
+                (lock.kind, lock.source.clone())
+            };
+            match kind {
+                // A typedef is its own type-definition.
+                DMLSymbolKind::Typedef => {
+                    let lock = sym.lock().unwrap();
+                    results.extend(lock.definitions.iter().copied());
+                }
+                // For variables and method args, walk the resolved type.
+                DMLSymbolKind::Saved
+                | DMLSymbolKind::Session
+                | DMLSymbolKind::Extern
+                | DMLSymbolKind::Local
+                | DMLSymbolKind::Constant
+                | DMLSymbolKind::MethodArg => {
+                    if let Some(ty) = resolved_type_from_symbol_source(&source) {
+                        if let Some(span) = outermost_typedef_span(ty) {
+                            results.push(span);
+                        }
+                    }
+                }
+                _ => {}
+            }
+        }
+    }
+    Ok(results)
+}
+
diff --git a/src/analysis/mod.rs b/src/analysis/mod.rs
index ab86ed9..002a6ba 100644
--- a/src/analysis/mod.rs
+++ b/src/analysis/mod.rs
@@ -1,6 +1,32 @@
 //  © 2024 Intel Corporation
 //  SPDX-License-Identifier: Apache-2.0 and MIT
 // Load parser and tree first to ensure existance of macros
+
+// This macro is made for transparently re-implmeneting trait fns into a
+// wrapper struct
+macro_rules! impl_trait_fns {
+    ($type: ty, $trait:ident, $field:tt,
+     $(fn $fn_name:ident(&self $(, $arg:ident: $arg_ty:ty)*) -> $ret:ty),*) => {
+        impl $trait for $type {
+            $(
+                fn $fn_name(&self, $($arg: $arg_ty),*) -> $ret {
+                    self.$field.$fn_name($($arg),*)
+                }
+            )*
+        }
+    };
+    ($type: ty, $trait:ident, $field:tt,
+     $(fn $fn_name:ident(self $(, $arg:ident: $arg_ty:ty)*) -> $ret:ty),*) => {
+        impl $trait for $type {
+            $(
+                fn $fn_name(self, $($arg: $arg_ty),*) -> $ret {
+                    self.$field.$fn_name($($arg),*)
+                }
+            )*
+        }
+    };
+}
+
 #[macro_use]
 pub mod parsing;
 #[macro_use]
@@ -41,11 +67,12 @@ use crate::analysis::provisionals::ProvisionalsManager;
 pub use crate::analysis::parsing::tree::
 {ZeroRange, ZeroSpan, ZeroPosition, ZeroFilePosition};
 
-use crate::analysis::parsing::tree::{MissingToken, MissingContent, TreeElement};
+use crate::analysis::parsing::tree::{MissingToken, MissingContent, TreeElement, TreeElementMember};
+use crate::analysis::parsing::types::{struct_or_layout_at_pos, StructOrLayoutRef};
 use crate::analysis::structure::objects::{CompObjectKind, Import, MaybeAbstract, ParamValue, Template};
 use crate::analysis::structure::statements::{ForPre, Statement, StatementKind};
 use crate::analysis::structure::toplevel::{ObjectDecl, TopLevel};
-use crate::analysis::structure::types::DMLType;
+use crate::analysis::structure::types::UnresolvedType;
 use crate::analysis::structure::expressions::{Expression, ExpressionKind,
                                               DMLString};
 use crate::analysis::templating::objects::{make_device, DMLObject,
@@ -62,7 +89,7 @@ use crate::analysis::templating::topology::{RankMaker,
 use crate::analysis::templating::methods::{DMLMethodArg, DMLMethodRef, DefaultCallReference, MethodDeclaration};
 use crate::analysis::templating::traits::{DMLTemplate,
                                           TemplateTraitInfo};
-use crate::analysis::templating::types::DMLResolvedType;
+use crate::analysis::templating::types::{DMLConcreteType, DMLStructType, DMLTraitType, DMLType, GlobalTypeStorage, eval_type_simple};
 
 use crate::concurrency::AliveStatus;
 use crate::file_management::{PathResolver, CanonPath};
@@ -163,6 +190,11 @@ impl <T: LocationSpan> LocationFile for T {
     }
 }
 
+// Used by things which we identify by their span
+pub trait IdentitySpan {
+    fn identity_span(&self) -> &ZeroSpan;
+}
+
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct DMLError {
     pub span: ZeroSpan,
@@ -350,15 +382,38 @@ pub struct SymbolStorage {
     pub method_symbols: HashMap<ZeroSpan, HashMap<StructureKey, SymbolRef>>,
     // constants, sessions, saveds, hooks, method args
     pub variable_symbols: HashMap<ZeroSpan, SymbolRef>,
+    // Typedefs, indexed by decl location
+    pub type_symbols: HashMap<ZeroSpan, SymbolRef>,
+    // struct member fields, indexed by containing struct decl location
+    pub struct_member_symbols: HashMap<ZeroSpan, HashMap<String, SymbolRef>>,
+    // trait member fields, indexed by trait name
+    pub trait_member_symbols: HashMap<String, HashMap<String, SymbolRef>>,
 }
 
 impl SymbolStorage {
-    pub fn all_symbols<'a>(&'a self) -> impl Iterator<Item = &'a SymbolRef> {
-        self.template_symbols.values()
-            .chain(self.param_symbols.values().flat_map(|h|h.values()))
-            .chain(self.object_symbols.values())
-            .chain(self.method_symbols.values().flat_map(|h|h.values()))
-            .chain(self.variable_symbols.values())
+    pub fn all_symbols(&self) -> impl Iterator<Item = SymbolRef> + '_ {
+        self.template_symbols.values().cloned()
+            .chain(self.param_symbols.values().flat_map(|h|h.values().cloned()))
+            .chain(self.object_symbols.values().cloned())
+            .chain(self.method_symbols.values().flat_map(|h|h.values().cloned()))
+            .chain(self.variable_symbols.values().cloned())
+            .chain(self.type_symbols.values().cloned())
+            .chain(self.struct_member_symbols.values().flat_map(|h|h.values().cloned()))
+            .chain(self.trait_member_symbols.values().flat_map(|h|h.values().cloned()))
+    }
+}
+
+fn for_each_struct_type(ty: &DMLType, visited: &mut HashSet<ZeroSpan>,
+                        visit: &mut impl FnMut(&DMLStructType)) {
+    let Some(FieldContainer::Struct(st)) = DeviceAnalysis::peel_to_field_container(ty) else {
+        return;
+    };
+    if !visited.insert(*st.identity_span()) {
+        return;
+    }
+    visit(&st);
+    for (_, member_ty) in &st.members {
+        for_each_struct_type(member_ty, visited, visit);
     }
 }
 
@@ -379,6 +434,8 @@ pub struct DeviceAnalysis {
     pub reference_info: ReferenceStorage,
     pub template_object_implementation_map: HashMap<ZeroSpan,
                                                     Vec<StructureKey>>,
+    pub type_storage: GlobalTypeStorage,
+    pub symbol_maker: Arc<SymbolMaker>,
     pub path: CanonPath,
     pub dependant_files: Vec<CanonPath>,
     pub clientpath: PathBuf,
@@ -492,8 +549,8 @@ impl ReferenceMatches {
     }
 }
 
-/// TODO: Consider usage and variants of type hints
-pub type TypeHint = DMLResolvedType;
+// TODO: Consider usage and variants of type hints
+pub type TypeHint = DMLType;
 
 // Agnostic reference
 type AgnRef = Vec<String>;
@@ -718,6 +775,21 @@ impl From<AnalysisError> for AnalysisProcessResult<()> {
     }
 }
 
+enum FieldContainer {
+    Struct(DMLStructType),
+    Trait(DMLTraitType),
+}
+
+// For things which are identified by their spans
+impl IdentitySpan for FieldContainer {
+    fn identity_span(&self) -> &ZeroSpan {
+        match self {
+            Self::Struct(st) => st.identity_span(),
+            Self::Trait(t) => t.identity_span(),
+        }
+    }
+}
+
 impl DeviceAnalysis {
     pub fn lookup_symbols<'t>(&self, context_sym: &ContextedSymbol<'t>, limitations: &mut HashSet<DLSLimitation>)
         -> Result<Vec<SymbolRef>, String> {
@@ -1134,7 +1206,28 @@ impl DeviceAnalysis {
                     }
             },
             // TODO: type lookup
-            ReferenceKind::Type => (),
+            ReferenceKind::Type => {
+                if let Some(loc) = self.type_storage.typedef_decl_span(&reference.name) {
+                        if let Some(type_sym) =
+                            self.symbol_info.type_symbols.get(&loc) {
+                                ref_matches.add_match(Arc::clone(type_sym));
+                        } else {
+                            error!("Unexpectedly missing a typedef symbol {}",
+                                   reference.name);
+                        }
+                } else if let Some(templ) = self.templates
+                    .templates.get(&reference.name) {
+                    // A Type-kind reference may name a template (DML "trait
+                    // type"). Fall back to the template's symbol so
+                    // goto-def/decl/ref work on template-as-type uses.
+                    if let Some(templ_loc) = &templ.location {
+                        if let Some(templ_sym) =
+                            self.symbol_info.template_symbols.get(templ_loc) {
+                            ref_matches.add_match(Arc::clone(templ_sym));
+                        }
+                    }
+                }
+            },
             _ => error!("Invalid global reference kind in {:?}", reference),
         }
         ref_matches
@@ -1184,8 +1277,17 @@ impl DeviceAnalysis {
                     Err(format!("Unexpectedly missing template matching {:?}", sym))
                 }
             },
-            // TODO: DMLType lookup
-            DMLSymbolKind::Typedef => Ok(vec![]),
+            DMLSymbolKind::Typedef => {
+                if let Some(loc) = self.type_storage.typedef_decl_span(sym.name.as_str()) {
+                    if let Some(type_sym) = self.symbol_info.type_symbols.get(&loc) {
+                        Ok(vec![Arc::clone(type_sym)])
+                    } else {
+                        Err(format!("Unexpectedly missing typedef symbol matching {:?}", sym))
+                    }
+                } else {
+                    Ok(vec![])
+                }
+            },
             // TODO: Extern lookup
             DMLSymbolKind::Extern => Ok(vec![]),
             e => {
@@ -1226,10 +1328,55 @@ impl DeviceAnalysis {
         // We can ignore messages from lookup defs here, as this lookup is
         // live and reporting additional things from here makes no sense
         if let Some(matches) = refs.as_matches() {
-            Ok(matches.into_iter().collect())
-        } else {
-            Ok(vec![])
+            return Ok(matches.into_iter().collect());
+        }
+        // No device-tree object implements the innermost enclosing context.
+        // This is expected (not an error) for a param/session/saved declared
+        // inside a template that is only ever used as a type and never
+        // `is`-instantiated: such a template has no corresponding object in
+        // the device tree at all, but its members are still meaningful as
+        // type members. `extend_with_trait_members` registers a symbol for
+        // each of them directly in `self.symbol_info.trait_member_symbols`,
+        // so look it up there instead.
+        if let Some(ContextKey::Template(templ)) = sym.contexts.last() {
+            if let Some(member_sym) = self.symbol_info.trait_member_symbols.get(&templ.get_name())
+                .and_then(|m|m.get(&sym.symbol.get_name())) {
+                    // We successfully resolved this via the template's
+                    // type-member symbols, so the "cannot evaluate without
+                    // an instantiating object" limitation inserted by
+                    // `context_to_objs` above doesn't apply here.
+                    limitations.remove(
+                        &isolated_template_limitation(&templ.get_name()));
+                    return Ok(vec![Arc::clone(member_sym)]);
+                }
         }
+        Ok(vec![])
+    }
+
+    // Looks up a member-decl. Takes ast passed-in from above to find
+    // containing spans for structs
+    pub fn member_symbol_at_pos(&self, pos: &ZeroFilePosition,
+                                ast: &dyn TreeElementMember) -> Option<SymbolRef> {
+        if let Some(found) = struct_or_layout_at_pos(ast, pos.position) {
+            let range = match found {
+                StructOrLayoutRef::Struct(s) => s.range(),
+                StructOrLayoutRef::Layout(l) => l.range(),
+            };
+            let span = ZeroSpan::from_range(range, pos.path());
+            if let Some(member_sym) = self.symbol_info.struct_member_symbols.get(&span)
+                          .and_then(|m|m.values()
+                          .find(|sym|sym.lock().unwrap().loc.contains_pos(pos))
+                          .cloned()) {
+                return Some(member_sym);
+            }
+        }
+        let container = self.templates.templates.values()
+            .filter(|templ|templ.spec.span().contains_pos(pos))
+            .max_by_key(|templ|templ.spec.span().range.start())?;
+        self.symbol_info.trait_member_symbols.get(&container.name)?
+            .values()
+            .find(|sym|sym.lock().unwrap().loc.contains_pos(pos))
+            .map(Arc::clone)
     }
 
     fn resolve_noderef_in_symbol<'t>(&'t self,
@@ -1241,28 +1388,153 @@ impl DeviceAnalysis {
         let sym = symbol.lock().unwrap();
         match &sym.source {
             SymbolSource::DMLObject(obj) => {
-                // The performance overhead is cloning here
-                // is _probably_ smaller than the one of holding the key
+                // The performance overhead of cloning here is _probably_
+                // smaller than the one of holding the lock
                 let obj_copy = obj.clone();
                 drop(sym);
                 self.resolve_noderef_in_obj(&obj_copy,
                                             node,
                                             method_structure,
                                             ref_matches);
+                // Fall back to resolving the noderef as a field reference
+                if ref_matches.as_matches().is_none() {
+                    if let Some(ty) = obj_copy.resolved_type() {
+                        self.resolve_struct_field_in_type(ty, node, ref_matches);
+                    }
+                }
             },
             SymbolSource::Method(key, method) => {
                 self.resolve_noderef_in_method(key, method, node, method_structure, ref_matches);
             },
-            // TODO: Cannot be resolved without constant folding
-            SymbolSource::MethodArg(_method, _name) => (),
-            SymbolSource::MethodLocal(_method, _name) => (),
-            // TODO: Fix once type system is sorted
-            SymbolSource::Type(_typed) => (),
+            // TODO: For now, we can only resolve noderefs through method args and
+            // locals through their perhaps-struct-typed fields
+
+            // Method args and locals can only be usefully sub-referenced when
+            // their resolved type is (a chain of typedefs down to) a struct
+            // type; in that case a `Simple` sub-ref names a struct field.
+            SymbolSource::MethodArg(..)
+            | SymbolSource::MethodLocal(..)
+            | SymbolSource::Type(..) => {
+                let resolved_type = sym.source.resolved_type().cloned();
+                drop(sym);
+                if let Some(ty) = resolved_type {
+                    self.resolve_struct_field_in_type(&ty, node, ref_matches);
+                }
+            },
             // TODO: Handle lookups inside templates
             SymbolSource::Template(_templ) => (),
         }
     }
 
+    // Get the containing struct/template of a field
+    fn peel_to_field_container(ty: &DMLType) -> Option<FieldContainer> {
+        let mut cur: DMLType = ty.clone();
+        loop {
+            let concrete = cur?;
+            cur = match concrete.as_ref() {
+                DMLConcreteType::StructType(st) =>
+                    return Some(FieldContainer::Struct(st.clone())),
+                DMLConcreteType::Trait(t) =>
+                    return Some(FieldContainer::Trait(t.clone())),
+                other => other.peel_one()?.clone(),
+            };
+        }
+    }
+
+    fn struct_field(st: &DMLStructType, name: &str) -> Option<(ZeroSpan, DMLType)> {
+        for (member_name, ty) in &st.members {
+            if let Some(n) = member_name {
+                if n.val == name {
+                    return Some((n.span, ty.clone()));
+                }
+            }
+        }
+        None
+    }
+
+    fn make_struct_field_symbol(&self,
+                                field_span: ZeroSpan,
+                                field_type: DMLType) -> SymbolRef {
+        let sym = self.symbol_maker.new_symbol(
+            field_span,
+            // local symbol kind is similar enough to a field declaration we can re-use it here.
+            DMLSymbolKind::Local,
+            SymbolSource::Type(field_type),
+        );
+        {
+            let mut lock = sym.lock().unwrap();
+            lock.definitions.push(field_span);
+            lock.declarations.push(field_span);
+        }
+        sym
+    }
+
+    fn field_symbol_of(&self, container: &FieldContainer, name: &str)
+        -> Option<SymbolRef> {
+        match container {
+            FieldContainer::Struct(st) =>
+                self.symbol_info.struct_member_symbols.get(st.identity_span())?
+                    .get(name).map(Arc::clone),
+            FieldContainer::Trait(t) =>
+                self.symbol_info.trait_member_symbols.get(&t.decl_name.val)?
+                    .get(name).map(Arc::clone),
+        }
+    }
+
+    pub fn fields_of_type_symbol(&self, type_sym: &SymbolRef)
+        -> Option<HashMap<String, SymbolRef>> {
+        let lock = type_sym.lock().unwrap();
+        let ty = lock.source.resolved_type()?;
+        match Self::peel_to_field_container(ty)? {
+            FieldContainer::Struct(st) =>
+                self.symbol_info.struct_member_symbols.get(st.identity_span()).cloned(),
+            FieldContainer::Trait(t) =>
+                self.symbol_info.trait_member_symbols.get(&t.decl_name.val).cloned(),
+        }
+    }
+
+    fn resolve_struct_field_in_type(&self,
+                                    ty: &DMLType,
+                                    node: &NodeRef,
+                                    ref_matches: &mut ReferenceMatches) {
+        match node {
+            NodeRef::Simple(simple) => {
+                let Some(container) = Self::peel_to_field_container(ty) else { return; };
+                if let Some(sym) = self.field_symbol_of(&container, &simple.val) {
+                    ref_matches.add_match(sym);
+                } else if let FieldContainer::Struct(st) = &container {
+                    if let Some((span, field_ty)) = Self::struct_field(st, &simple.val) {
+                        // Fallback: struct wasn't pre-registered (anonymous or
+                        // otherwise unreachable at analysis-build time). Still
+                        // produce a match so goto-def works, but goto-ref may
+                        // not include this reference.
+                        let sym = self.make_struct_field_symbol(span, field_ty);
+                        ref_matches.add_match(sym);
+                    }
+                }
+            }
+            NodeRef::Sub(subnode, simple, _) => {
+                // Recursively resolve the intermediate expression's type
+                // against this same struct chain.
+                let mut intermediate = ReferenceMatches::new();
+                self.resolve_struct_field_in_type(ty, subnode, &mut intermediate);
+                if let Some(syms) = intermediate.as_matches() {
+                    for sym in syms {
+                        // Clone the typeref so we can drop the lock immediately
+                        let inner_ty = sym.lock().unwrap().source.resolved_type().cloned();
+                        if let Some(inner_ty) = inner_ty {
+                            let wrapped = NodeRef::Simple(simple.clone());
+                            self.resolve_struct_field_in_type(
+                                &inner_ty, &wrapped, ref_matches);
+                        }
+                    }
+                } else {
+                    ref_matches.merge_with(intermediate);
+                }
+            }
+        }
+    }
+
     fn get_method_symbol(&self,
                          method: &Arc<DMLMethodRef>,
                          parent_obj_key: &StructureKey)
@@ -1885,6 +2157,7 @@ impl IsolatedAnalysis {
 fn objects_to_symbols(maker: &SymbolMaker,
                       objects: &StructureContainer,
                       errors: &mut Vec<DMLError>,
+                      types: &mut GlobalTypeStorage,
                       method_structure: &mut HashMap
                       <ZeroSpan, RangeEntry>) -> SymbolStorage {
     let mut storage = SymbolStorage::default();
@@ -1900,6 +2173,7 @@ fn objects_to_symbols(maker: &SymbolMaker,
                 add_new_symbol_from_shallow(maker,
                                             shallow,
                                             errors,
+                                            types,
                                             &mut storage,
                                             method_structure);
             }
@@ -1939,6 +2213,85 @@ fn extend_with_templates(maker: &SymbolMaker,
     }
 }
 
+fn extend_with_types(maker: &SymbolMaker,
+                     storage: &mut SymbolStorage,
+                     type_storage: &GlobalTypeStorage) {
+    for (name, loc) in type_storage.typedef_decl_spans() {
+        // Fetch the fully-resolved `DMLType` for this typedef from the
+        // global type storage. Since the typedef declaration itself is the
+        // "definition of the type", the source carries the resolved
+        // `Typedef`-wrapped DMLType.
+        let resolved = type_storage.typedef_as_type(name);
+        let sym = symbol_ref!(
+            maker,
+            loc,
+            DMLSymbolKind::Typedef,
+            SymbolSource::Type(resolved),
+            bases = vec![loc],
+            definitions = vec![loc],
+            declarations = vec![loc]
+        );
+        if let Some(prev) = storage.type_symbols.insert(loc, sym) {
+            internal_error!("Unexpectedly two type symbols defined in the same location");
+            error!("Previous was {:?}", prev);
+        }
+    }
+}
+
+fn extend_with_struct_fields(maker: &SymbolMaker, symbols: &mut SymbolStorage,
+                             type_storage: &GlobalTypeStorage) {
+    let mut visited: HashSet<ZeroSpan> = HashSet::new();
+    for ty in type_storage.resolved_types() {
+        for_each_struct_type(ty, &mut visited, &mut |st| {
+            symbols.struct_member_symbols.entry(*st.identity_span()).or_insert_with(|| {
+                st.members.iter()
+                    .filter_map(|(member_name, member_ty)| {
+                        let name = member_name.as_ref()?;
+                        let field_span = name.span;
+                        let sym = symbol_ref!(
+                            maker,
+                            field_span,
+                            DMLSymbolKind::Local,
+                            SymbolSource::Type(member_ty.clone()),
+                            bases = vec![field_span],
+                            definitions = vec![field_span],
+                            declarations = vec![field_span]
+                        );
+                        Some((name.val.clone(), sym))
+                    })
+                    .collect()
+            });
+        });
+    }
+}
+
+fn extend_with_trait_members(maker: &SymbolMaker, symbols: &mut SymbolStorage,
+                             templates: &TemplateTraitInfo) {
+    for (name, template) in &templates.templates {
+        let trait_info = &template.traitspec;
+        symbols.trait_member_symbols.entry(name.clone()).or_insert_with(|| {
+            trait_info.params.values()
+                .chain(trait_info.sessions.values())
+                .chain(trait_info.saveds.values())
+                .map(|decl| {
+                    let member_span = decl.name.span;
+                    let sym = symbol_ref!(
+                        maker,
+                        member_span,
+                        DMLSymbolKind::Local,
+                        SymbolSource::Type(decl.type_ref.clone()),
+                        bases = vec![member_span],
+                        definitions = vec![member_span],
+                        declarations = vec![member_span]
+                    );
+                    (decl.name.val.clone(), sym)
+                })
+                .collect()
+        });
+    }
+}
+
+
 fn new_symbol_from_object(maker: &SymbolMaker,
                           object: &DMLCompositeObject) -> SymbolRef {
     let all_decl_defs = &object.all_decls;
@@ -1964,7 +2317,8 @@ fn new_symbol_from_arg(maker: &SymbolMaker,
         maker,
         *arg.loc_span(),
         DMLSymbolKind::MethodArg,
-        SymbolSource::MethodArg(Arc::clone(methref), arg.name().clone()),
+        SymbolSource::MethodArg(Arc::clone(methref), arg.name().clone(),
+                               arg.resolved_type()),
         bases = bases,
         definitions = definitions,
         declarations = declarations
@@ -2000,7 +2354,7 @@ where K: std::hash::Hash + Eq + Clone + std::fmt::Debug,
 // Create a symbol for each level of overriding for each object where the method
 // is actualized. We then end up with many symbols for the same decl location,
 // and leave it to requests to collect the aggregate information at the point
-fn add_new_symbol_from_method(maker: &SymbolMaker, parent_obj_key: &StructureKey, method_ref: &Arc<DMLMethodRef>, errors: &mut Vec<DMLError>, storage: &mut SymbolStorage, method_structure: &mut HashMap<ZeroSpan, RangeEntry>) {
+fn add_new_symbol_from_method(maker: &SymbolMaker, parent_obj_key: &StructureKey, method_ref: &Arc<DMLMethodRef>, errors: &mut Vec<DMLError>, types: &mut GlobalTypeStorage, storage: &mut SymbolStorage, method_structure: &mut HashMap<ZeroSpan, RangeEntry>) {
     let (bases, definitions, declarations) = (
         method_ref.get_bases().iter().map(|b|*b.location()).collect(),
         vec![*method_ref.get_decl().location()],
@@ -2022,10 +2376,10 @@ fn add_new_symbol_from_method(maker: &SymbolMaker, parent_obj_key: &StructureKey
             let new_argsymbol = new_symbol_from_arg(maker, method_ref, arg);
             log_non_same_insert(&mut storage.variable_symbols, *arg.loc_span(), new_argsymbol);
         }
-        add_method_scope_symbols(maker, method_ref, method_structure, storage, errors);
+        add_method_scope_symbols(maker, method_ref, method_structure, types, storage, errors);
         if let Some(defaults) = method_ref.get_default() {
             for default in defaults.flat_refs() {
-                add_new_symbol_from_method(maker, parent_obj_key, default, errors, storage, method_structure);
+                add_new_symbol_from_method(maker, parent_obj_key, default, errors, types, storage, method_structure);
             }
         }
     }
@@ -2035,6 +2389,7 @@ fn add_new_symbol_from_method(maker: &SymbolMaker, parent_obj_key: &StructureKey
 fn add_new_symbol_from_shallow(maker: &SymbolMaker,
                                shallow: &DMLShallowObject,
                                errors: &mut Vec<DMLError>,
+                               types: &mut GlobalTypeStorage,
                                storage: &mut SymbolStorage,
                                method_structure: &mut HashMap
                                <ZeroSpan, RangeEntry>) {
@@ -2046,7 +2401,7 @@ fn add_new_symbol_from_shallow(maker: &SymbolMaker,
              param.declarations.iter()
                 .map(|(_, def)|*def.loc_span()).collect()),
         DMLShallowObjectVariant::Method(method_ref) =>
-            return add_new_symbol_from_method(maker, &shallow.parent, method_ref, errors, storage, method_structure),
+            return add_new_symbol_from_method(maker, &shallow.parent, method_ref, errors, types, storage, method_structure),
         DMLShallowObjectVariant::Constant(constant) =>
             (vec![*constant.loc_span()],
              vec![*constant.loc_span()],
@@ -2101,6 +2456,7 @@ fn add_method_scope_symbols(maker: &SymbolMaker,
                             method: &Arc<DMLMethodRef>,
                             method_structure: &mut HashMap<ZeroSpan,
                                                            RangeEntry>,
+                            types: &mut GlobalTypeStorage,
                             storage: &mut SymbolStorage,
                             errors: &mut Vec<DMLError>) {
     let mut entry = RangeEntry {
@@ -2113,6 +2469,7 @@ fn add_method_scope_symbols(maker: &SymbolMaker,
                                      method,
                                      &method.get_decl().body,
                                      errors,
+                                     types,
                                      storage,
                                      &mut entry);
     }
@@ -2126,20 +2483,22 @@ fn add_method_scope_symbols(maker: &SymbolMaker,
 fn add_new_method_scope_symbol<T>(maker: &SymbolMaker,
                                   method: &Arc<DMLMethodRef>,
                                   sym: &T,
-                                  _typ: &DMLType,
+                                  typ: &UnresolvedType,
+                                  types: &mut GlobalTypeStorage,
+                                  errors: &mut Vec<DMLError>,
                                   storage: &mut SymbolStorage,
                                   scope: &mut RangeEntry)
 where
     T : StructureSymbol + DMLNamed + LocationSpan
 {
+    let resolved = eval_type_simple(typ, types, errors);
     let symbol = symbol_ref!(
         maker,
         *sym.loc_span(),
         sym.kind(),
-        SymbolSource::MethodLocal(Arc::clone(method), sym.name().clone()),
+        SymbolSource::MethodLocal(Arc::clone(method), sym.name().clone(), resolved),
         definitions = vec![*sym.loc_span()],
         declarations = vec![*sym.loc_span()]
-        // TODO: resolve type
     );
     scope.symbols.insert(sym.name().val.clone(), Arc::clone(&symbol));
     storage.variable_symbols.insert(*sym.loc_span(), symbol);
@@ -2151,6 +2510,7 @@ fn enter_new_method_scope(maker: &SymbolMaker,
                           stmnt: &Statement,
                           scope_span: &ZeroSpan,
                           errors: &mut Vec<DMLError>,
+                          types: &mut GlobalTypeStorage,
                           storage: &mut SymbolStorage,
                           scope: &mut RangeEntry) {
     // In DMLC, there is no error or warning about this (even if a declaration
@@ -2176,6 +2536,7 @@ fn enter_new_method_scope(maker: &SymbolMaker,
                                  method,
                                  stmnt,
                                  errors,
+                                 types,
                                  storage,
                                  &mut entry);
     scope.sub_ranges.push(entry);
@@ -2185,6 +2546,7 @@ fn add_new_method_scope_symbols(maker: &SymbolMaker,
                                 method: &Arc<DMLMethodRef>,
                                 stmnt: &Statement,
                                 errors: &mut Vec<DMLError>,
+                                types: &mut GlobalTypeStorage,
                                 storage: &mut SymbolStorage,
                                 scope: &mut RangeEntry) {
     match &**stmnt {
@@ -2194,6 +2556,7 @@ fn add_new_method_scope_symbols(maker: &SymbolMaker,
                                              method,
                                              sub_stmnt,
                                              errors,
+                                             types,
                                              storage,
                                              scope);
             },
@@ -2204,6 +2567,7 @@ fn add_new_method_scope_symbols(maker: &SymbolMaker,
                                    &content.ifbody,
                                    content.ifbody.span(),
                                    errors,
+                                   types,
                                    storage,
                                    scope);
             if let Some(elsebody) = &content.elsebody {
@@ -2213,6 +2577,7 @@ fn add_new_method_scope_symbols(maker: &SymbolMaker,
                                        elsebody,
                                        elsebody.span(),
                                        errors,
+                                       types,
                                        storage,
                                        scope);
             }
@@ -2225,6 +2590,7 @@ fn add_new_method_scope_symbols(maker: &SymbolMaker,
                                    &content.ifbody,
                                    content.ifbody.span(),
                                    errors,
+                                   types,
                                    storage,
                                    scope);
             if let Some(elsebody) = &content.elsebody {
@@ -2234,6 +2600,7 @@ fn add_new_method_scope_symbols(maker: &SymbolMaker,
                                        elsebody,
                                        elsebody.span(),
                                        errors,
+                                       types,
                                        storage,
                                        scope);
             }
@@ -2245,6 +2612,7 @@ fn add_new_method_scope_symbols(maker: &SymbolMaker,
                                    &content.body,
                                    content.body.span(),
                                    errors,
+                                   types,
                                    storage,
                                    scope),
         StatementKind::DoWhile(content) =>
@@ -2254,6 +2622,7 @@ fn add_new_method_scope_symbols(maker: &SymbolMaker,
                                    &content.body,
                                    content.body.span(),
                                    errors,
+                                   types,
                                    storage,
                                    scope),
         StatementKind::For(content) => {
@@ -2269,6 +2638,8 @@ fn add_new_method_scope_symbols(maker: &SymbolMaker,
                                                 method,
                                                 decl,
                                                 &decl.typed,
+                                                types,
+                                                errors,
                                                 storage,
                                                 &mut entry);
                 }
@@ -2279,6 +2650,7 @@ fn add_new_method_scope_symbols(maker: &SymbolMaker,
                                    &content.body,
                                    content.body.span(),
                                    errors,
+                                   types,
                                    storage,
                                    &mut entry);
             scope.sub_ranges.push(entry);
@@ -2295,7 +2667,11 @@ fn add_new_method_scope_symbols(maker: &SymbolMaker,
                                         method,
                                         &content.ident,
                                         // TODO: infer type
-                                        content.ident.loc_span(),
+                                        // (element of inexpr type)
+                                        &UnresolvedType::make_invalid(
+                                            *content.inexpr.span()),
+                                        types,
+                                        errors,
                                         storage,
                                         &mut entry);
             enter_new_method_scope(maker,
@@ -2304,6 +2680,7 @@ fn add_new_method_scope_symbols(maker: &SymbolMaker,
                                    &content.selectbranch,
                                    content.selectbranch.span(),
                                    errors,
+                                   types,
                                    storage,
                                    &mut entry);
             scope.sub_ranges.push(entry);
@@ -2313,6 +2690,7 @@ fn add_new_method_scope_symbols(maker: &SymbolMaker,
                                    &content.elsebranch,
                                    content.elsebranch.span(),
                                    errors,
+                                   types,
                                    storage,
                                    scope);
         },
@@ -2323,6 +2701,7 @@ fn add_new_method_scope_symbols(maker: &SymbolMaker,
                                    &content.tryblock,
                                    content.tryblock.span(),
                                    errors,
+                                   types,
                                    storage,
                                    scope);
             enter_new_method_scope(maker,
@@ -2331,6 +2710,7 @@ fn add_new_method_scope_symbols(maker: &SymbolMaker,
                                    &content.catchblock,
                                    content.catchblock.span(),
                                    errors,
+                                   types,
                                    storage,
                                    scope);
         },
@@ -2341,6 +2721,8 @@ fn add_new_method_scope_symbols(maker: &SymbolMaker,
                     method,
                     decl,
                     &decl.typed,
+                    types,
+                    errors,
                     storage,
                     scope);
             },
@@ -2356,6 +2738,7 @@ impl DeviceAnalysis {
                                      &str, &ObjectDecl<Template>>,
                              files: &HashMap<&str, &TopLevel>,
                              imp_map: &HashMap<Import, CanonPath>,
+                             types: &mut GlobalTypeStorage,
                              errors: &mut Vec<DMLError>)
                              -> TemplateTraitInfo {
         info!("Rank templates");
@@ -2365,7 +2748,7 @@ impl DeviceAnalysis {
         create_templates_traits(
             start_of_file,
             rank_maker, templates, order,
-            invalid_isimps, imp_map, rank_struct, errors)
+            invalid_isimps, imp_map, rank_struct, types, errors)
     }
 
     fn match_references(&mut self,
@@ -2497,22 +2880,67 @@ impl DeviceAnalysis {
                    base.path.to_str().unwrap_or("no path"));
         }
         status.check_alive()?;
+        // Register all typedefs from all base files with the global type
+        // storage so they are available for resolution during templating,
+        // reporting conflicts (including template/typedef overlaps) along
+        // the way. Built-in named types ("int", "char", "size_t", ...) are
+        // generated once here as part of construction (see
+        // `GlobalTypeStorage::new`).
+        let mut type_storage = GlobalTypeStorage::new(root.path.clone());
+        for base in &bases {
+            for typedef in &base.toplevel.typedefs {
+                let name = typedef.name();
+                if let Some(prev_span) = type_storage.add_typedef(typedef) {
+                    errors.push(DMLError {
+                        span: *typedef.object.loc_span(),
+                        description: format!("Duplicate typedef name; '{}'",
+                                             name.val),
+                        severity: Some(DiagnosticSeverity::ERROR),
+                        related: vec![(
+                            prev_span,
+                            "Previously defined here".to_string()
+                        )],
+                    });
+                } else if let Some(templ) = unique_templates.get(name.val.as_str()) {
+                    errors.push(DMLError {
+                        span: *typedef.object.loc_span(),
+                        description: format!(
+                            "Typedef name '{}' collides with a template name",
+                            name.val),
+                        severity: Some(DiagnosticSeverity::ERROR),
+                        related: vec![(
+                            *templ.obj.object.loc_span(),
+                            "Template defined here".to_string()
+                        )],
+                    });
+                }
+            }
+        }
+
+        // Track templates-as-types
+        for template in unique_templates.values() {
+            type_storage.add_template(template.obj.object.name.clone());
+        }
+
+        type_storage.resolve_all(&mut errors);
+
         let mut rank_maker = RankMaker::new();
         let tt_info = Self::make_templates_traits(&root.toplevel.start_of_file,
                                                   &mut rank_maker,
                                                   &unique_templates,
                                                   &files,
                                                   &imp_map,
+                                                  &mut type_storage,
                                                   &mut errors);
         status.check_alive()?;
-        // TODO: catch typedef/traitname overlaps
 
-        // TODO: this is where we would do type resolution
         let mut container = StructureContainer::default();
         info!("Make device");
         let device_key = make_device(&root.path, &root.toplevel,
                                      &tt_info, imp_map, &mut container,
-                                     &mut rank_maker, &mut errors).key;
+                                     &mut rank_maker,
+                                     &mut type_storage,
+                                     &mut errors).key;
         status.check_alive()?;
         // maps template declaration loc to objects
         let template_object_implementation_map =
@@ -2526,19 +2954,21 @@ impl DeviceAnalysis {
         // NAME of the methoddecl
         let mut method_structure: HashMap<ZeroSpan, RangeEntry>
             = HashMap::default();
-        let maker = SymbolMaker::new();
+        let maker = Arc::new(SymbolMaker::new());
         let mut symbol_info = objects_to_symbols(&maker,
                                                  &container,
                                                  &mut errors,
+                                                 &mut type_storage,
                                                  &mut method_structure);
         // This needs to be done after all symbols are created, because method
         // symbol order is not correlated to the object iteration order
         bind_method_implementations(&mut symbol_info.method_symbols);
 
         status.check_alive()?;
-        // TODO: how do we store type info?
         extend_with_templates(&maker, &mut symbol_info, &tt_info);
-        //extend_with_types(&mut symbols, ??)
+        extend_with_types(&maker, &mut symbol_info, &type_storage);
+        extend_with_struct_fields(&maker, &mut symbol_info, &type_storage);
+        extend_with_trait_members(&maker, &mut symbol_info, &tt_info);
         let mut device = DeviceAnalysis {
             name: root.toplevel.device.unwrap().name.val,
             errors: HashMap::default(),
@@ -2548,6 +2978,8 @@ impl DeviceAnalysis {
             symbol_info,
             reference_info: ReferenceStorage::default(),
             template_object_implementation_map,
+            type_storage,
+            symbol_maker: maker,
             path: root.path.clone(),
             clientpath: root.path.clone().into(),
             dependant_files: bases.iter().map(|b|&b.path).cloned().collect(),
@@ -2621,7 +3053,7 @@ impl DeviceAnalysis {
             let mut syms = vec![];
             for sym in self.symbol_info.all_symbols() {
                 if sym.lock().unwrap().references.contains(&loc) {
-                    syms.push(Arc::clone(sym));
+                    syms.push(sym);
                 }
             }
             locked_info.insert(loc, syms);
diff --git a/src/analysis/parsing/tree.rs b/src/analysis/parsing/tree.rs
index 7c1c002..6db7030 100644
--- a/src/analysis/parsing/tree.rs
+++ b/src/analysis/parsing/tree.rs
@@ -18,10 +18,17 @@ pub type ZeroFilePosition = FilePosition::<ZeroIndexed>;
 
 // Marker trait, let's us implement things on things containing
 // treeelements without specifying the long list of trai
+// `'static` + `as_any` lets callers downcast a `&dyn TreeElementMember`
+// back to a concrete node type, e.g. to find the innermost AST node of a
+// specific kind containing a given position (see `struct_or_layout_at_pos`).
 pub trait TreeElementMember
-    : TreeElement + ReferenceContainer + std::fmt::Debug {}
-impl <T: TreeElement + ReferenceContainer + std::fmt::Debug>
-    TreeElementMember for T {}
+    : TreeElement + ReferenceContainer + std::fmt::Debug + 'static {
+    fn as_any(&self) -> &dyn std::any::Any;
+}
+impl <T: TreeElement + ReferenceContainer + std::fmt::Debug + 'static>
+    TreeElementMember for T {
+    fn as_any(&self) -> &dyn std::any::Any { self }
+}
 
 pub type TreeElements<'t> = Vec<&'t dyn TreeElementMember>;
 pub type TreeElementTokenIterator = Vec<Token>;
@@ -326,6 +333,15 @@ pub struct AstObject<T: Clone + PartialEq> {
     pub content: Box<Content<T>>,
 }
 
+impl <T: TreeElement + Clone + PartialEq + 'static> AstObject<T> {
+    pub fn as_actual<'a>(&'a self) -> Option<&'a T> {
+        match self.content.as_ref() {
+            Content::Some(content) => Some(content),
+            Content::Missing(_) => None,
+        }
+    }
+}
+
 impl <T: MaybeIsNodeRef + Clone + PartialEq + 'static> MaybeIsNodeRef for AstObject<T> {
     fn maybe_noderef<'a>(&self, file: FileSpec<'a>) -> Option<NodeRef> {
         self.with_content(|content|content.maybe_noderef(file), None)
diff --git a/src/analysis/parsing/types.rs b/src/analysis/parsing/types.rs
index e9745d2..54c58c3 100644
--- a/src/analysis/parsing/types.rs
+++ b/src/analysis/parsing/types.rs
@@ -1,23 +1,45 @@
 //  © 2024 Intel Corporation
 //  SPDX-License-Identifier: Apache-2.0 and MIT
-use crate::lint::{rules::{indentation::{IndentCodeBlockArgs, IndentClosingBraceArgs},
-                            spacing::SpBracesArgs,
-                            CurrentRules},
-                            AuxParams,
-                            DMLStyleError};
+use crate::{analysis::structure::types::string_to_endianness, lint::{AuxParams, DMLStyleError, rules::{CurrentRules, indentation::{IndentClosingBraceArgs, IndentCodeBlockArgs}, spacing::SpBracesArgs}}};
 use crate::span::Range;
 use crate::analysis::parsing::lexer::TokenKind;
 use crate::analysis::parsing::parser::{doesnt_understand_tokens,
                                        FileParser, Parse, ParseContext,
                                        FileInfo};
-use crate::analysis::parsing::tree::{AstObject, TreeElement, TreeElements,
-                            LeafToken, ZeroRange};
+use crate::analysis::parsing::tree::{AstObject, TreeElement, TreeElementMember,
+                            TreeElements, LeafToken, ZeroPosition, ZeroRange};
 use crate::analysis::parsing::misc::{CDecl, ident_filter};
 use crate::analysis::parsing::expression::Expression;
 use crate::analysis::reference::{CodeReference, Reference, ReferenceKind};
 use crate::analysis::{FileSpec, LocalDMLError};
 use crate::vfs::TextFile;
 
+#[derive(Debug)]
+pub enum StructOrLayoutRef<'t> {
+    Struct(&'t StructTypeContent),
+    Layout(&'t LayoutContent),
+}
+
+// Find the innermost struct/layout at a position
+pub fn struct_or_layout_at_pos<'t>(node: &'t dyn TreeElementMember, pos: ZeroPosition)
+    -> Option<StructOrLayoutRef<'t>> {
+    if !node.range().contains_pos(pos) {
+        return None;
+    }
+    for sub in node.subs() {
+        if let Some(found) = struct_or_layout_at_pos(sub, pos) {
+            return Some(found);
+        }
+    }
+    if let Some(s) = node.as_any().downcast_ref::<StructTypeContent>() {
+        return Some(StructOrLayoutRef::Struct(s));
+    }
+    if let Some(l) = node.as_any().downcast_ref::<LayoutContent>() {
+        return Some(StructOrLayoutRef::Layout(l));
+    }
+    None
+}
+
 pub fn typeident_filter(token: TokenKind) -> bool {
     match token {
         TokenKind::Identifier |
@@ -91,7 +113,7 @@ impl Parse<BaseTypeContent> for StructTypeContent {
             }
         }
         let rbrace = new_context.expect_next_kind(stream, TokenKind::RBrace);
-        BaseTypeContent::StructType(StructTypeContent {
+        BaseTypeContent::Struct(StructTypeContent {
             structtok,
             lbrace,
             members,
@@ -125,9 +147,10 @@ impl TreeElement for LayoutContent {
         for (field, _) in &self.fields {
             errors.append(&mut field.ensure_named());
         }
+        // TODO: Consider not checking this here, and instead
+        // checking during structural conversion (we have to convert anyway)
         if let Some(byteorder) = self.byteorder.read_leaf(file) {
-            if byteorder != r#""big-endian""# &&
-                byteorder != r#""little-endian""# {
+            if string_to_endianness(byteorder.as_str()).is_none() {
                 errors.push(LocalDMLError {
                     range: self.byteorder.range(),
                     description: "Must be 'big-endian' or \
@@ -466,7 +489,7 @@ impl Parse<BaseTypeContent> for HookTypeContent {
             args.push((arg, comma));
         }
         let rparen = new_context.expect_next_kind(stream, TokenKind::RParen);
-        BaseTypeContent::HookType(HookTypeContent {
+        BaseTypeContent::Hook(HookTypeContent {
             hook, lparen, args, rparen
         }).into()
     }
@@ -475,12 +498,12 @@ impl Parse<BaseTypeContent> for HookTypeContent {
 #[derive(Debug, Clone, PartialEq)]
 pub enum BaseTypeContent {
     Ident(LeafToken),
-    StructType(StructTypeContent),
+    Struct(StructTypeContent),
     Layout(LayoutContent),
     Bitfields(BitfieldsContent),
     TypeOf(TypeOfContent),
     Sequence(SequenceContent),
-    HookType(HookTypeContent),
+    Hook(HookTypeContent),
 }
 
 impl TreeElement for BaseTypeContent {
@@ -499,23 +522,23 @@ impl TreeElement for BaseTypeContent {
     fn range(&self) -> ZeroRange {
         match self {
             Self::Ident(content) => content.range(),
-            Self::StructType(content) => content.range(),
+            Self::Struct(content) => content.range(),
             Self::Layout(content) => content.range(),
             Self::Bitfields(content) => content.range(),
             Self::TypeOf(content) => content.range(),
             Self::Sequence(content) => content.range(),
-            Self::HookType(content) => content.range(),
+            Self::Hook(content) => content.range(),
         }
     }
     fn subs(&self) -> TreeElements<'_> {
         match self {
             Self::Ident(content) => create_subs![content],
-            Self::StructType(content) => create_subs![content],
+            Self::Struct(content) => create_subs![content],
             Self::Layout(content) => create_subs![content],
             Self::Bitfields(content) => create_subs![content],
             Self::TypeOf(content) => create_subs![content],
             Self::Sequence(content) => create_subs![content],
-            Self::HookType(content) => create_subs![content],
+            Self::Hook(content) => create_subs![content],
         }
     }
 }
@@ -645,6 +668,7 @@ impl Parse<CTypeDeclSimpleContent> for CTypeDeclSimple {
     }
 }
 
+// NOTE: this is a  'ctypedecl' which is a C-style typedecl with NO identifier
 #[derive(Debug, Clone, PartialEq)]
 pub struct CTypeDeclContent {
     pub consttok: Option<LeafToken>,
@@ -695,6 +719,7 @@ impl CTypeDeclContent {
 mod test {
     use super::*;
     use crate::test_helpers::*;
+    use logos::Logos;
 
     #[test]
     fn ctypedecl() {
@@ -726,4 +751,40 @@ mod test {
                       }),
             &vec![])
     }
+
+    fn parse_base_type(source: &str) -> BaseType {
+        let lexer = TokenKind::lexer(source);
+        let mut fileparse = FileParser::new(lexer);
+        let top_context = ParseContext::new_context(doesnt_understand_tokens);
+        let file_info = FileInfo::default();
+        BaseType::parse(&top_context, &mut fileparse, &file_info)
+    }
+
+    #[test]
+    fn struct_or_layout_at_pos_finds_innermost_nested_match() {
+        let source = "struct { struct { int x; } inner; \
+                       layout \"big-endian\" { int y; } lay; int z; }";
+        let ast = parse_base_type(source);
+        let root: &dyn TreeElementMember = &ast;
+
+        match struct_or_layout_at_pos(root, zero_position(0, 22)) {
+            Some(StructOrLayoutRef::Struct(s)) =>
+                assert_eq!(s.range(), zero_range(0, 0, 9, 26)),
+            other => panic!("Expected inner struct, got {:?}", other),
+        }
+
+        match struct_or_layout_at_pos(root, zero_position(0, 60)) {
+            Some(StructOrLayoutRef::Layout(l)) =>
+                assert_eq!(l.range(), zero_range(0, 0, 34, 64)),
+            other => panic!("Expected layout, got {:?}", other),
+        }
+
+        match struct_or_layout_at_pos(root, zero_position(0, 74)) {
+            Some(StructOrLayoutRef::Struct(s)) =>
+                assert_eq!(s.range(), ast.range()),
+            other => panic!("Expected outer struct, got {:?}", other),
+        }
+
+        assert!(struct_or_layout_at_pos(root, zero_position(1, 0)).is_none());
+    }
 }
diff --git a/src/analysis/reference.rs b/src/analysis/reference.rs
index 6aafc16..42193b1 100644
--- a/src/analysis/reference.rs
+++ b/src/analysis/reference.rs
@@ -5,7 +5,7 @@ use crate::analysis::parsing::tree::{LeafToken, TreeElement};
 use crate::analysis::structure::expressions::{DMLString};
 use crate::analysis::FileSpec;
 
-#[derive(Debug, Clone, Hash, PartialEq, Eq, PartialOrd, Ord)]
+#[derive(Debug, Clone, Hash, PartialEq, Eq, PartialOrd)]
 pub enum NodeRef {
     Simple(DMLString),
     //// Ignore index here
@@ -42,7 +42,7 @@ impl DeclarationSpan for NodeRef {
     }
 }
 
-#[derive(Debug, Clone, Hash, PartialEq, Eq, PartialOrd, Ord)]
+#[derive(Debug, Clone, Hash, PartialEq, Eq, PartialOrd)]
 pub struct VariableReference {
     pub reference: NodeRef,
     pub kind: ReferenceKind,
@@ -67,7 +67,7 @@ impl LocationSpan for VariableReference {
     }
 }
 
-#[derive(Debug, Clone, Hash, PartialEq, Eq, PartialOrd, Ord)]
+#[derive(Debug, Clone, Hash, PartialEq, Eq, PartialOrd)]
 pub struct GlobalReference {
     pub name: String,
     pub loc: ZeroSpan,
@@ -93,7 +93,7 @@ impl DeclarationSpan for GlobalReference {
     }
 }
 
-#[derive(Copy, Debug, Clone, Hash, PartialEq, Eq, PartialOrd, Ord)]
+#[derive(Copy, Debug, Clone, Hash, PartialEq, Eq, PartialOrd)]
 pub enum ReferenceKind {
     Template,
     Type,
@@ -101,7 +101,7 @@ pub enum ReferenceKind {
     Callable,
 }
 
-#[derive(Debug, Clone, Hash, PartialEq, Eq, PartialOrd, Ord)]
+#[derive(Debug, Clone, Hash, PartialEq, Eq, PartialOrd)]
 pub enum ReferenceVariant {
     Variable(VariableReference),
     Global(GlobalReference),
@@ -110,18 +110,18 @@ pub enum ReferenceVariant {
 // NOTE: Since this information is likely to be sparse, use
 // boxes for any non-trivially small fields. If fields get to be more
 // than a few, the entire info should probably be boxed instead
-#[derive(Debug, Default, Clone, Hash, PartialEq, Eq, PartialOrd, Ord)]
+#[derive(Debug, Default, Clone, Hash, PartialEq, Eq, PartialOrd)]
 pub struct ReferenceInfo {
     pub was_instantiation: bool,
 }
 
-#[derive(Debug, Clone, Hash, PartialEq, Eq, PartialOrd, Ord)]
+#[derive(Debug, Clone, Hash, PartialEq, Eq, PartialOrd)]
 pub struct CodeReference {
     pub variant: ReferenceVariant,
     pub extra_info: ReferenceInfo,
 }
 
-#[derive(Debug, Clone, Hash, PartialEq, Eq, PartialOrd, Ord)]
+#[derive(Debug, Clone, Hash, PartialEq, Eq, PartialOrd)]
 pub enum Reference {
     CodeReference(CodeReference),
     FileReference(DMLString),
@@ -213,6 +213,13 @@ impl CodeReference {
         }
     }
 
+    pub fn as_global_ref(&self) -> Option<&GlobalReference> {
+        match &self.variant {
+            ReferenceVariant::Global(glob) => Some(glob),
+            _ => None,
+        }
+    }
+
     pub fn from_noderef(node: NodeRef, kind: ReferenceKind) -> CodeReference {
         CodeReference {
             variant: ReferenceVariant::Variable(VariableReference {
diff --git a/src/analysis/structure/expressions.rs b/src/analysis/structure/expressions.rs
index aa19b92..c0596d3 100644
--- a/src/analysis/structure/expressions.rs
+++ b/src/analysis/structure/expressions.rs
@@ -12,7 +12,7 @@ use crate::analysis::parsing::tree::{LeafToken, ZeroRange,
                                      ZeroSpan, TreeElement};
 use crate::analysis::FileSpec;
 use crate::analysis::structure::types;
-use crate::analysis::structure::types::DMLType;
+use crate::analysis::structure::types::UnresolvedType;
 
 use crate::analysis::{DeclarationSpan, LocalDMLError};
 use crate::analysis::templating::objects::StructureKey;
@@ -73,7 +73,7 @@ pub enum BinOp {
     Logic(LogicOp),
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd)]
 pub struct BinaryExpression {
     pub span: ZeroSpan,
     pub left: Expression,
@@ -129,7 +129,7 @@ impl DeclarationSpan for BinaryExpression {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd)]
 pub struct MemberLiteral {
     pub span: ZeroSpan,
     pub left: Expression,
@@ -168,7 +168,7 @@ impl DeclarationSpan for MemberLiteral {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd)]
 pub struct TertiaryExpression {
     pub span: ZeroSpan,
     pub left: Expression,
@@ -216,7 +216,7 @@ impl TertiaryExpression {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd)]
 pub struct UnaryExpression {
     pub span: ZeroSpan,
     pub operand: Expression,
@@ -261,7 +261,7 @@ pub fn to_unary_expression<'a>(operation: &LeafToken,
     }).into()
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd)]
 pub struct SliceExpression {
     pub span: ZeroSpan,
     pub target: Expression,
@@ -293,7 +293,7 @@ impl DeclarationSpan for SliceExpression {
 }
 
 
-#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd)]
 pub struct Identifier {
     pub name: DMLString,
 }
@@ -317,7 +317,7 @@ impl DeclarationSpan for Identifier {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd)]
 pub struct FunctionCall {
     pub span: ZeroSpan,
     pub function: Expression,
@@ -346,11 +346,11 @@ impl DeclarationSpan for FunctionCall {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd)]
 pub struct CastExpression {
     pub span: ZeroSpan,
     pub from: Expression,
-    pub to: DMLType,
+    pub to: UnresolvedType,
 }
 
 impl CastExpression {
@@ -374,7 +374,7 @@ impl DeclarationSpan for CastExpression {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd)]
 pub struct IndexExpression {
     pub span: ZeroSpan,
     pub array: Expression,
@@ -402,10 +402,10 @@ impl DeclarationSpan for IndexExpression {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd)]
 pub struct NewExpression {
     pub span: ZeroSpan,
-    pub valuetype: DMLType,
+    pub valuetype: UnresolvedType,
     pub amount: Option<Expression>,
 }
 
@@ -429,7 +429,7 @@ impl DeclarationSpan for NewExpression {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd)]
 pub struct SizeOf {
     pub span: ZeroSpan,
     pub sizeof: Expression,
@@ -453,10 +453,10 @@ impl DeclarationSpan for SizeOf {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd)]
 pub struct SizeOfType {
     pub span: ZeroSpan,
-    pub typed: DMLType,
+    pub typed: UnresolvedType,
 }
 
 impl SizeOfType {
@@ -481,7 +481,7 @@ impl DeclarationSpan for SizeOfType {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd)]
 pub struct ConstantList {
     pub span: ZeroSpan,
     pub list: Vec<Expression>
@@ -507,7 +507,7 @@ impl DeclarationSpan for ConstantList {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd)]
 pub struct EachIn {
     pub span: ZeroSpan,
     pub templ: DMLString,
@@ -537,7 +537,7 @@ impl DeclarationSpan for EachIn {
 // since this is implicit from the tree structure
 pub type Expression = Box<ExpressionKind>;
 
-#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd)]
 pub enum IntegerLiteral {
     Signed(Value<i64>),
     Unsigned(Value<u64>),
@@ -552,7 +552,7 @@ impl DeclarationSpan for IntegerLiteral {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd)]
 pub enum ExpressionKind {
     TertiaryExpression(TertiaryExpression),
     BinaryExpression(BinaryExpression),
@@ -677,6 +677,8 @@ fn ast_to_literal<'a>(ast: &LeafToken,
                     }))
             },
             _ => {
+                // TODO/RE-EXAMINE: Are unqualified integer literals
+                // actually always unsigned?
                 let raw_val = tok_str.replace(['_'],"");
                 ExpressionKind::IntegerLiteral(
                     IntegerLiteral::Unsigned(
@@ -810,7 +812,7 @@ impl DMLString {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Hash)]
 pub struct InitializerStruct {
     initializer_fields: Vec<(DMLString,
                              Box<SingleInitializer>)>,
@@ -850,7 +852,7 @@ impl DeclarationSpan for InitializerStruct {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Hash)]
 pub struct InitializerList {
     list: Vec<SingleInitializer>,
     span: ZeroSpan,
@@ -881,7 +883,7 @@ impl DeclarationSpan for InitializerList {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Hash)]
 pub enum SingleInitializer {
     Expression(Expression),
     List(InitializerList),
@@ -925,7 +927,7 @@ impl DeclarationSpan for SingleInitializer {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Hash)]
 pub struct InitializerTuple {
     pub list: Vec<SingleInitializer>,
     pub span: ZeroSpan,
@@ -956,7 +958,7 @@ impl DeclarationSpan for InitializerTuple {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Hash)]
 pub enum Initializer {
     Single(SingleInitializer),
     Tuple(InitializerTuple),
diff --git a/src/analysis/structure/mod.rs b/src/analysis/structure/mod.rs
index 6e17ad1..54d6215 100644
--- a/src/analysis/structure/mod.rs
+++ b/src/analysis/structure/mod.rs
@@ -1,7 +1,62 @@
 //  © 2024 Intel Corporation
 //  SPDX-License-Identifier: Apache-2.0 and MIT
+
+#[cfg(test)]
+macro_rules! assert_match_destruct {
+    ($e: expr, $p: pat $(, $i: ident)*) => {{
+        let &$p = &$e else {
+            panic!("{:?} did not match {}", $e, stringify!($p));
+        };
+        #[allow(clippy::unused_unit)]
+        ($($i),*)
+    }}
+}
+
+#[cfg(test)]
+pub mod test {
+    use crate::analysis::{FileSpec, LocalDMLError, TokenKind};
+    use crate::analysis::parsing::parser::{
+        FileParser,
+        FileInfo,
+        ParseContext,
+        Parse,
+        doesnt_understand_tokens,
+    };
+    use crate::analysis::parsing::tree::TreeElement;
+    use crate::vfs::TextFile;
+
+    use logos::Logos;
+    use std::path::Path;
+    use std::str::FromStr;
+
+    pub fn parse_to_structure<C, PT, F, T>(source: &str, reparse_fun: F)
+        -> Option<(T, Vec<LocalDMLError>)>
+        where C: PartialEq + Clone + TreeElement + std::fmt::Debug + 'static,
+              PT: Parse<C>,
+              F: Fn(&C,
+                    &mut Vec<LocalDMLError>,
+                    FileSpec<'_>) -> T
+    {
+        let lexer = TokenKind::lexer(source);
+        let mut fileparse = FileParser::new(lexer);
+        let top_context = ParseContext::new_context(doesnt_understand_tokens);
+        let file_info = FileInfo::default();
+        let mut ast_errors = vec![];
+        let file = &TextFile::from_str(source).expect("Failed to create textfile");
+        let maybe_ast = PT::parse(&top_context, &mut fileparse, &file_info);
+        assert!(fileparse.skipped_tokens.is_empty(), "Parse error: skipped tokens {:#?}",
+                fileparse.skipped_tokens);
+        let parse_tree = maybe_ast.as_actual()?;
+        let ast = reparse_fun(parse_tree, &mut ast_errors, FileSpec {
+            path: Path::new("TestingInFile"), file,
+        });
+        Some((ast, ast_errors))
+    }
+}
+
 pub mod types;
 pub mod statements;
 pub mod objects;
 pub mod expressions;
 pub mod toplevel;
+
diff --git a/src/analysis/structure/objects.rs b/src/analysis/structure/objects.rs
index 502d114..165c20f 100644
--- a/src/analysis/structure/objects.rs
+++ b/src/analysis/structure/objects.rs
@@ -7,7 +7,9 @@ use crate::analysis::parsing::tree::{LeafToken, ZeroRange,
 use crate::analysis::structure::expressions::{Expression, Value, DMLString,
                                               ExpressionKind};
 use crate::analysis::structure::statements::{Statement, StatementKind};
-use crate::analysis::structure::types::{DMLType, deconstruct_cdecl, to_type};
+use crate::analysis::structure::types::{UnresolvedType,
+                                        cdecls_to_members,
+                                        deconstruct_cdecl, to_type};
 use crate::analysis::FileSpec;
 use crate::analysis::{LocalDMLError, DeclarationSpan, LocationSpan, DMLNamed,
                       Named};
@@ -45,12 +47,12 @@ pub trait MaybeAbstract {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Hash)]
 pub enum DMLBitorder {
     BE, LE,
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Hash)]
 pub struct Bitorder {
     pub span: ZeroSpan,
     pub order: Value<DMLBitorder>,
@@ -83,7 +85,7 @@ impl ToStructure<structure::BitorderContent> for Bitorder {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Hash)]
 pub struct Device {
     pub decl: CompObjectKindDecl,
     pub name: DMLString,
@@ -117,7 +119,7 @@ impl DMLNamed for Device {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Hash)]
 pub struct Version {
     pub span: ZeroSpan,
     pub major_version: Value<u8>,
@@ -183,7 +185,7 @@ impl DeclarationSpan for Version {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Hash)]
 pub struct Export {
     pub span: ZeroSpan,
     pub target: Expression,
@@ -212,7 +214,7 @@ impl DeclarationSpan for Export {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Hash)]
 pub struct CBlock {
     pub span: ZeroSpan,
     pub cblock: String,
@@ -238,26 +240,22 @@ impl DeclarationSpan for CBlock {
 // TODO: We are missing a fair bit of error reporting for hooks:
 // Check uses of hooks (both "send_now" and after bindings) for argument number
 // Check that shared hooks are only declared in traits
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Hash)]
 pub struct Hook {
     pub shared: bool,
     pub object: DMLObjectCommon,
-    pub args: Vec<DMLType>,
+    pub args: Vec<UnresolvedType>,
 }
 
 impl ToStructure<structure::HookContent> for Hook {
     fn to_structure<'a>(content: &structure::HookContent,
                         report: &mut Vec<LocalDMLError>,
                         file: FileSpec<'a>) -> Option<Hook> {
-        let mut args = vec![];
-        for (cdecl, _) in content.arg_types.iter() {
-            // Name is non-semantic for hooks
-            if let (_, Some(typed)) = cdecl.with_content(
-                |con|deconstruct_cdecl(con, report, file),
-                (None, None)) {
-                args.push(typed);
-            }
-        }
+        let args = cdecls_to_members(content.arg_types.iter()
+                                     .map(|(decl, _)|decl),
+                                     report,
+                                     file)
+            .into_iter().map(|(_, typing)|typing).collect();
         Some(Hook {
             shared: content.shared.is_some(),
             args,
@@ -288,7 +286,7 @@ impl StructureSymbol for Hook {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Hash)]
 pub struct Import {
     pub span: ZeroSpan,
     pub name: DMLString,
@@ -323,7 +321,7 @@ impl Import {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Hash)]
 pub struct InEach {
     pub loc: ZeroSpan,
     pub span: ZeroSpan,
@@ -412,7 +410,7 @@ impl ToStructure<structure::InEachContent> for InEach {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Hash)]
 pub struct Loggroup {
     pub span: ZeroSpan,
     pub name: DMLString,
@@ -447,7 +445,7 @@ impl StructureSymbol for Loggroup {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Hash)]
 pub struct Instantiation {
     pub span: ZeroSpan,
     pub names: Vec<DMLString>,
@@ -485,7 +483,7 @@ impl DeclarationSpan for Instantiation {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Hash)]
 pub struct Error {
     pub span: ZeroSpan,
     // No need to track exact location of the message
@@ -517,7 +515,7 @@ impl DeclarationSpan for Error {
 // We store instantiations and errors seperately, since
 // their semantics are special, but storing them is common
 // enough that we want a struct for it
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Hash)]
 pub struct Statements {
     pub instantiations: Vec<Instantiation>,
     pub errors: Vec<Error>,
@@ -555,7 +553,7 @@ impl SymbolContainer for Statements {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Hash)]
 enum DMLStatementKind {
     Error(Error),
     Instantiation(Instantiation),
@@ -608,7 +606,7 @@ fn to_objectstatements<'a>(list: &structure::ObjectStatementsContent,
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Hash)]
 pub enum DMLStatement {
     Object(DMLObject),
     HashIf(HashIf),
@@ -653,7 +651,7 @@ impl SymbolContainer for DMLStatement {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Hash)]
 pub struct Template {
     pub object: DMLObjectCommon,
     pub statements: Statements,
@@ -736,7 +734,7 @@ impl ToStructure<structure::TemplateContent> for Template {
 }
 
 // A special case,
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Hash)]
 pub struct HashIf {
     pub span: ZeroSpan,
     pub condition: Expression,
@@ -803,7 +801,7 @@ impl DeclarationSpan for HashIf {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Hash)]
 pub struct DMLObjectCommon {
     pub name: DMLString,
     pub span: ZeroSpan,
@@ -821,7 +819,7 @@ impl DMLNamed for DMLObjectCommon {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Hash)]
 pub struct ArrayDim {
     pub span: ZeroSpan,
     pub indexvar: DMLString,
@@ -872,7 +870,7 @@ impl CompObjectKind {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Hash)]
 pub struct CompObjectKindDecl {
     pub kind: CompObjectKind,
     pub span: ZeroSpan,
@@ -902,7 +900,7 @@ impl CompObjectKindDecl {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Hash)]
 pub struct CompositeObject {
     pub kind: CompObjectKindDecl,
     pub object: DMLObjectCommon,
@@ -970,9 +968,9 @@ pub enum MethodModifier {
     None, Shared, Inline
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Hash)]
 pub enum MethodArgument {
-    Typed(DMLString, DMLType),
+    Typed(DMLString, UnresolvedType),
     Inline(DMLString),
 }
 
@@ -991,11 +989,11 @@ impl StructureSymbol for MethodArgument {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Hash)]
 pub struct Method {
     pub object: DMLObjectCommon,
     pub arguments: Vec<MethodArgument>,
-    pub returns: Vec<DMLType>,
+    pub returns: Vec<UnresolvedType>,
     pub modifier: MethodModifier,
     pub independent: bool,
     // TODO: we could track startup here, but is there any
@@ -1056,10 +1054,12 @@ impl ToStructure<structure::MethodContent> for Method {
         for (arg, _) in &content.arguments {
             match arg {
                 structure::ArgumentDecl::Typed(ast_decl) =>
-                    if let (Some(name), Some(typed)) = ast_decl.with_content(
-                        |con|deconstruct_cdecl(con, report, file),
-                        (None, None)) {
-                        arguments.push(MethodArgument::Typed(name, typed));
+                    if let Some(content) = ast_decl.as_actual() {
+                        if let (Some(name), typed)
+                            = deconstruct_cdecl(content, report, file) {
+                                arguments.push(
+                                    MethodArgument::Typed(name, typed));
+                            }
                     },
                 structure::ArgumentDecl::Inline(_, ast_name) =>
                     if let Some(name) = DMLString::from_token(ast_name, file) {
@@ -1076,6 +1076,27 @@ impl ToStructure<structure::MethodContent> for Method {
                 }
             }
         }
+
+        for arg in &arguments {
+            if let MethodArgument::Typed(_, UnresolvedType::Struct(s)) = arg {
+                report.push(LocalDMLError {
+                    range: s.span().range,
+                    description:
+                        "Cannot use anonymous struct type in argument type"
+                        .to_string(),
+                });
+            }
+        }
+        for ret in &returns {
+            if let UnresolvedType::Struct(s) = ret {
+                report.push(LocalDMLError {
+                    range: s.span().range,
+                    description:
+                        "Cannot use anonymous struct type in return type"
+                        .to_string(),
+                });
+            }
+        }
         let object = DMLObjectCommon {
             name: DMLString::from_token(&content.name, file)?,
             span: ZeroSpan::from_range(content.range(), file.path),
@@ -1113,18 +1134,18 @@ impl ToStructure<structure::MethodContent> for Method {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Hash)]
 pub enum ParamValue {
     Set(Expression),
     Auto(ZeroSpan),
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Hash)]
 pub struct Parameter {
     pub object: DMLObjectCommon,
     pub is_default: bool,
     pub value: Option<ParamValue>,
-    pub typed: Option<DMLType>,
+    pub typed: Option<UnresolvedType>,
 }
 
 impl DeclarationSpan for Parameter {
@@ -1179,7 +1200,7 @@ impl ToStructure<structure::ParameterContent> for Parameter {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Hash)]
 pub struct Initializer {
     span: ZeroSpan,
     kind: InitializerKind
@@ -1214,7 +1235,7 @@ impl From<InitializerKind> for Initializer {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Hash)]
 pub enum InitializerKind {
     One(Expression),
     List(Vec<Box<Initializer>>),
@@ -1283,7 +1304,7 @@ fn to_initializer<'a>(content: &misc::InitializerContent,
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Hash)]
 pub enum VariableDeclKind {
     Extern,
     Saved,
@@ -1291,14 +1312,14 @@ pub enum VariableDeclKind {
     Local,
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Hash)]
 pub struct VariableDecl {
     // While-span is hidden away inside object
     pub object: DMLObjectCommon,
     // This is redundant in structure, but becomes highly useful later
     // when we flatten variables into their decls
     pub kind: VariableDeclKind,
-    pub typed: DMLType,
+    pub typed: UnresolvedType,
 }
 
 impl DeclarationSpan for VariableDecl {
@@ -1328,9 +1349,7 @@ fn to_variable_decl_structure<'a>(content: &misc::CDecl,
                                   kind: VariableDeclKind,
                                   report: &mut Vec<LocalDMLError>,
                                   file: FileSpec<'a>) -> Option<VariableDecl> {
-    let (name, typed) = content.with_content(
-        |con|deconstruct_cdecl(con, report, file),
-        (None, None));
+    let (name, typed) = deconstruct_cdecl(content.as_actual()?, report, file);
     // Fair to discard a variable declaration if it doesnt have a name
     let object = DMLObjectCommon {
         name: name?,
@@ -1339,11 +1358,11 @@ fn to_variable_decl_structure<'a>(content: &misc::CDecl,
     Some(VariableDecl {
         object,
         kind,
-        typed: typed?,
+        typed,
     })
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Hash)]
 pub struct Variable {
     pub vars: Vec<VariableDecl>,
     pub values: Vec<Initializer>,
@@ -1422,7 +1441,7 @@ pub fn to_variable_structure<'a>(decls: &structure::VarDecl,
     })
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Hash)]
 pub struct Constant {
     pub object: DMLObjectCommon,
     pub value: Expression,
@@ -1464,11 +1483,11 @@ impl ToStructure<structure::ConstantContent> for Constant {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Hash)]
 pub struct Typedef {
     pub is_extern: bool,
     pub object: DMLObjectCommon,
-    pub typed: DMLType,
+    pub typed: UnresolvedType,
 }
 
 impl ToStructure<structure::TypedefContent> for Typedef {
@@ -1476,9 +1495,8 @@ impl ToStructure<structure::TypedefContent> for Typedef {
                         report: &mut Vec<LocalDMLError>,
                         file: FileSpec<'a>) -> Option<Typedef> {
         let is_extern = content.externtok.is_some();
-        let (name, typed) = content.decl.with_content(
-            |con|deconstruct_cdecl(con, report, file),
-            (None, None));
+        let (name, typed) = deconstruct_cdecl(content.decl.as_actual()?,
+                                              report, file);
         let object = DMLObjectCommon {
             name: name?,
             span: ZeroSpan::from_range(content.range(), file.path),
@@ -1486,9 +1504,7 @@ impl ToStructure<structure::TypedefContent> for Typedef {
         Some(Typedef {
             is_extern,
             object,
-            // TODO: We need to be able to store partially resolved objects
-            // TODO/NOTE: Applies at least everywhere there is a deconstruct_cdecl
-            typed: typed?,
+            typed,
         })
     }
 }
@@ -1505,7 +1521,13 @@ impl DMLNamed for Typedef {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+impl StructureSymbol for Typedef {
+    fn kind(&self) -> DMLSymbolKind {
+        DMLSymbolKind::Typedef
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Hash)]
 pub enum DMLObject {
     Bitorder(Bitorder),
     CompositeObject(CompositeObject),
diff --git a/src/analysis/structure/statements.rs b/src/analysis/structure/statements.rs
index b63ce40..dfc674f 100644
--- a/src/analysis/structure/statements.rs
+++ b/src/analysis/structure/statements.rs
@@ -18,7 +18,7 @@ use crate::analysis::parsing::lexer::TokenKind;
 use crate::analysis::parsing::tree::{LeafToken, ZeroSpan, TreeElement};
 use crate::analysis::{DMLNamed, DMLSymbolKind, FileSpec};
 
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Hash)]
 pub struct ForEachIdentifier(DMLString);
 
 impl DeclarationSpan for ForEachIdentifier {
@@ -39,7 +39,7 @@ impl StructureSymbol for ForEachIdentifier {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Hash)]
 pub struct ForEach {
     pub identifier: ForEachIdentifier,
     pub inexpr: Expression,
@@ -78,7 +78,7 @@ impl DeclarationSpan for ForEach {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Hash)]
 pub struct If {
     pub condition: Expression,
     pub ifbody: Statement,
@@ -119,7 +119,7 @@ impl DeclarationSpan for If {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Hash)]
 pub struct HashIf {
     pub condition: Expression,
     pub ifbody: Statement,
@@ -159,7 +159,7 @@ impl DeclarationSpan for HashIf {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Hash)]
 pub struct HashIfCase {
     pub condition: Expression,
     pub truecases: Vec<SwitchCase>,
@@ -200,7 +200,7 @@ impl DeclarationSpan for HashIfCase {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Hash)]
 pub enum SwitchCase {
     Statement(Statement),
     Case(Expression),
@@ -252,7 +252,7 @@ impl DeclarationSpan for SwitchCase {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Hash)]
 pub struct Switch {
     pub expr: Expression,
     pub cases: Vec<SwitchCase>,
@@ -285,7 +285,7 @@ impl DeclarationSpan for Switch {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Hash)]
 pub struct While {
     pub cond: Expression,
     pub body: Statement,
@@ -318,7 +318,7 @@ impl DeclarationSpan for While {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Hash)]
 pub struct DoWhile {
     pub cond: Expression,
     pub body: Statement,
@@ -351,14 +351,14 @@ impl DeclarationSpan for DoWhile {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Hash)]
 pub enum ForPostElement {
     Expression(Expression),
     Assign(Vec<Expression>, Assigner),
     AssignOp(Expression, AssignOp, Expression),
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Hash)]
 pub enum ForPre {
     Declaration(Variable),
     Post(Vec<ForPostElement>),
@@ -373,7 +373,7 @@ impl SymbolContainer for ForPre {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Hash)]
 pub struct For {
     pub pre: Option<ForPre>,
     pub cond: Option<Expression>,
@@ -457,7 +457,7 @@ impl DeclarationSpan for For {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Hash)]
 pub enum AfterExpression {
     Timer(Expression),
     // Note: We allow None here in order to not double-report
@@ -466,7 +466,7 @@ pub enum AfterExpression {
     Hook(Expression, Vec<Option<String>>),
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Hash)]
 pub struct After {
     pub after: Option<AfterExpression>,
     pub call: Expression,
@@ -516,7 +516,7 @@ impl DeclarationSpan for After {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Hash)]
 pub struct Return {
     pub ret: Option<Initializer>,
     pub span: ZeroSpan,
@@ -541,7 +541,7 @@ impl DeclarationSpan for Return {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Hash)]
 pub struct Continue {
     pub span: ZeroSpan,
 }
@@ -564,7 +564,7 @@ impl DeclarationSpan for Continue {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Hash)]
 pub struct Break {
     pub span: ZeroSpan,
 }
@@ -587,7 +587,7 @@ impl Break {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Hash)]
 pub struct TryCatch {
     pub tryblock: Statement,
     pub catchblock: Statement,
@@ -623,7 +623,7 @@ impl DeclarationSpan for TryCatch {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Hash)]
 pub struct Throw {
     pub span: ZeroSpan,
 }
@@ -646,13 +646,13 @@ impl DeclarationSpan for Throw {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Hash)]
 pub enum LogLevel {
     Simple(Expression),
     Subsequent(Expression, Expression),
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Hash)]
 pub enum LogKind {
     SpecViol,
     Info,
@@ -662,7 +662,7 @@ pub enum LogKind {
     Warning,
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Hash)]
 pub struct Log {
     pub kind: LogKind,
     pub level: Option<LogLevel>,
@@ -734,7 +734,7 @@ impl DeclarationSpan for Log {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Hash)]
 pub struct Assert {
     pub expression: Expression,
     pub span: ZeroSpan,
@@ -760,7 +760,7 @@ impl DeclarationSpan for Assert {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Hash)]
 pub struct Delete {
     pub expression: Expression,
     pub span: ZeroSpan,
@@ -786,7 +786,7 @@ impl DeclarationSpan for Delete {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Hash)]
 pub struct Error {
     pub message: Option<Expression>,
     pub span: ZeroSpan,
@@ -847,14 +847,14 @@ fn to_statement_variable_decl<'a>(content: &statement::VariableDeclContent,
         file)?).into()
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Hash)]
 pub enum AssignOp {
     Plus, Minus, Times, Divide, Mod,
     BOr, BAnd, BXor,
     LShift, RShift,
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Hash)]
 pub struct AssignOpStatement {
     pub assignee: Expression,
     pub operation: AssignOp,
@@ -907,13 +907,13 @@ impl AssignOpStatement {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Hash)]
 pub enum Assigner {
     Initializer(Initializer),
     Chain(Vec<Expression>),
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Hash)]
 pub struct AssignStatement {
     pub assignees: Vec<Expression>,
     pub assigner: Assigner,
@@ -981,7 +981,7 @@ impl DeclarationSpan for AssignStatement {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Hash)]
 pub struct HashSelectIdent(DMLString);
 
 impl DMLNamed for HashSelectIdent {
@@ -996,7 +996,7 @@ impl StructureSymbol for HashSelectIdent {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Hash)]
 pub struct HashSelect {
     pub ident: HashSelectIdent,
     pub inexpr: Expression,
@@ -1047,7 +1047,7 @@ impl DeclarationSpan for HashSelect {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Hash)]
 pub struct CompoundStatement {
     pub statements: Vec<Statement>,
     pub span: ZeroSpan,
@@ -1080,7 +1080,7 @@ impl DeclarationSpan for CompoundStatement {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Hash)]
 pub struct ExpressionStatement {
     pub expression: Expression,
     pub span: ZeroSpan,
@@ -1108,7 +1108,7 @@ impl DeclarationSpan for ExpressionStatement {
 
 pub type Statement = Box<StatementKind>;
 
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Hash)]
 pub enum StatementKind {
     ForEach(ForEach),
     HashIf(HashIf),
diff --git a/src/analysis/structure/toplevel.rs b/src/analysis/structure/toplevel.rs
index 23a7fea..b35a76e 100644
--- a/src/analysis/structure/toplevel.rs
+++ b/src/analysis/structure/toplevel.rs
@@ -20,7 +20,7 @@ use crate::analysis::scope::{Scope, ScopeContainer, MakeScopeContainer,
                              ContextKey};
 
 
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Hash)]
 pub enum ExistCondition {
     Always,
     // The bool here is whether the expression should be reversed, as the
@@ -79,7 +79,7 @@ impl Display for StatementContext {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Hash)]
 pub struct ObjectDecl<T> where T: DeclarationSpan
 {
     pub cond: ExistCondition,
@@ -184,7 +184,7 @@ where T: DeclarationSpan {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Hash)]
 pub enum StatementSpecStatement<'t> {
     Object(&'t ObjectDecl<CompositeObject>),
     Instantiation(&'t ObjectDecl<Instantiation>),
@@ -221,7 +221,7 @@ impl StatementSpec {
     }
 }
 
-    #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+    #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Hash)]
 pub struct StatementSpec {
     pub objects: Vec<ObjectDecl<CompositeObject>>,
     pub sessions: Vec<ObjectDecl<Variable>>,
@@ -626,7 +626,9 @@ impl Scope for TopLevel {
         self.spec.scopes()
     }
     fn defined_symbols(&self) -> Vec<&dyn StructureSymbol> {
-        self.spec.symbols()
+        let mut syms = self.spec.symbols();
+        syms.extend(self.typedefs.iter().map(|t| t as &dyn StructureSymbol));
+        syms
     }
 }
 
diff --git a/src/analysis/structure/types.rs b/src/analysis/structure/types.rs
index b8e5e7a..226ed85 100644
--- a/src/analysis/structure/types.rs
+++ b/src/analysis/structure/types.rs
@@ -1,89 +1,1597 @@
 //  © 2024 Intel Corporation
 //  SPDX-License-Identifier: Apache-2.0 and MIT
 use crate::analysis::parsing::{misc, types};
-use crate::analysis::parsing::tree::{ZeroSpan, TreeElement};
-use crate::analysis::LocalDMLError;
-use crate::analysis::structure::expressions::DMLString;
-use crate::analysis::FileSpec;
+use crate::analysis::parsing::tree::{LeafToken, TreeElement, ZeroSpan};
+use crate::analysis::{DMLError, LocalDMLError, TokenKind};
+use crate::analysis::structure::expressions::{DMLString, Expression,
+                                              ExpressionKind};
+use crate::analysis::{FileSpec, DeclarationSpan};
+use crate::analysis::templating::types::{self as concrete_types, DMLConcreteType, DMLStructLabel, DMLType, GlobalTypeStorage, ResolvingState};
+use crate::analysis::parsing::types::CTypeDeclSimple;
 
-// TODO/NOTE: Currently we use the range of the declaration in source
-// as a placeholder for the actual type AST
-pub type DMLType = ZeroSpan;
+use std::collections::BTreeMap;
+use std::cmp::Ordering;
 
+use lsp_types::DiagnosticSeverity;
+use regex::Regex;
+use log::error;
+use lazy_static::lazy_static;
+
+/// This file describes UNRESOLVED DML types, these are later converted
+/// to resolved types with actual semantics later
+/// Structures that do not change when resolved are re-used in the final type
+/// description
+
+// Common information for all types
+#[derive(Debug, Clone, PartialEq, PartialOrd, Ord, Eq, Hash)]
+pub struct TypeBase {
+    pub is_const: bool,
+    // This is the area in the file where you would say the type is 'declared'
+    // roughly corresponding to some meaningful range that does not necessarily
+    // include the binding name
+    // For example, here the def area is the area of the "| ... |":
+    // |  |
+    // long foo;
+    // |           | (of the fn pointer type)
+    // long (*foo)();
+    // |                    |
+    // typedef struct { ... } foo;
+    pub decl_span: ZeroSpan,
+}
+
+impl TypeBase {
+    fn from_span(span: ZeroSpan) -> TypeBase {
+        TypeBase {
+            is_const: false,
+            decl_span: span,
+        }
+    }
+    fn from_leaf<'a>(leaf: &LeafToken, file: FileSpec<'a>) -> TypeBase {
+        TypeBase::from_span(ZeroSpan::from_range(leaf.range(), file.path))
+    }
+    fn make_const(self) -> TypeBase {
+        TypeBase {
+            is_const: true,
+            decl_span: self.decl_span,
+        }
+    }
+    pub fn equivalent(&self, other: &Self) -> bool {
+        self.is_const == other.is_const
+    }
+}
+
+impl DeclarationSpan for TypeBase {
+    fn span(&self) -> &ZeroSpan {
+        &self.decl_span
+    }
+}
+
+// Human-readable description of a type
+pub trait DescribableType {
+    fn describe(&self) -> String;
+}
+
+pub trait ResolveableType {
+    fn resolve(&self, global_info: &mut GlobalTypeStorage,
+              resolving: &mut ResolvingState,
+              is_extern: bool, via_indirection: bool,
+              errors: &mut Vec<DMLError>) -> DMLType;
+}
+
+macro_rules! impl_simple_from {
+    ($from_type: ty, $to_type: tt) => {
+        impl From<$from_type> for $to_type {
+            fn from(val: $from_type) -> $to_type {
+                $to_type(val)
+            }
+        }
+    };
+}
+
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Hash)]
+pub struct VoidType(TypeBase);
+impl_simple_from!(TypeBase, VoidType);
+impl_trait_fns!(VoidType, DeclarationSpan, 0, fn span(&self) -> &ZeroSpan);
+impl VoidType {
+    fn make_const(self) -> VoidType {
+        VoidType(self.0.make_const())
+    }
+    pub fn equivalent(&self, other: &Self) -> bool {
+        self.0.equivalent(&other.0)
+    }
+}
+impl DescribableType for VoidType {
+    fn describe(&self) -> String {
+        "void".to_string()
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Hash)]
+pub struct DeviceType(TypeBase);
+impl_simple_from!(TypeBase, DeviceType);
+impl_trait_fns!(DeviceType, DeclarationSpan, 0, fn span(&self) -> &ZeroSpan);
+impl DeviceType {
+    fn make_const(self) -> DeviceType {
+        DeviceType(self.0.make_const())
+    }
+    pub fn equivalent(&self, other: &Self) -> bool {
+        self.0.equivalent(&other.0)
+    }
+}
+impl DescribableType for DeviceType {
+    fn describe(&self) -> String {
+        "device".to_string()
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Hash)]
+pub struct NamedType {
+    pub base: TypeBase,
+    pub name: DMLString,
+}
+impl_trait_fns!(NamedType, DeclarationSpan, base, fn span(&self) -> &ZeroSpan);
+impl NamedType {
+    fn make_const(self) -> NamedType {
+        NamedType {
+            base: self.base.make_const(),
+            name: self.name,
+        }
+    }
+    pub fn equivalent(&self, other: &Self) -> bool {
+        self.base.equivalent(&other.base)
+    }
+}
+impl ResolveableType for NamedType {
+    fn resolve(&self, global_info: &mut GlobalTypeStorage,
+              resolving: &mut ResolvingState,
+              is_extern: bool, via_indirection: bool,
+              errors: &mut Vec<DMLError>) -> DMLType {
+        global_info.resolve_named(self, resolving, is_extern, via_indirection, errors)
+    }
+}
+
+// NOTE: If wanting to describe the underlying type, resolve first
+impl DescribableType for NamedType {
+    fn describe(&self) -> String {
+        self.name.val.to_string()
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Hash)]
+pub struct BoolType(TypeBase);
+impl_simple_from!(TypeBase, BoolType);
+impl_trait_fns!(BoolType, DeclarationSpan, 0, fn span(&self) -> &ZeroSpan);
+impl BoolType {
+    fn make_const(self) -> BoolType {
+        BoolType(self.0.make_const())
+    }
+    pub fn equivalent(&self, other: &Self) -> bool {
+        self.0.equivalent(&other.0)
+    }
+}
+impl DescribableType for BoolType {
+    fn describe(&self) -> String {
+        "bool".to_string()
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Hash)]
+pub enum Endianness {
+    LE, BE
+}
+
+impl Endianness {
+    pub fn short_desc(&self) -> &'static str {
+        match self {
+            Endianness::LE => "le",
+            Endianness::BE => "be",
+        }
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Hash)]
+pub struct EndianIntType {
+    base: TypeBase,
+    endian: Endianness,
+    size: u16,
+    signed: bool,
+}
+impl_trait_fns!(EndianIntType, DeclarationSpan, base, fn span(&self) -> &ZeroSpan);
+impl EndianIntType {
+    fn make_const(self) -> EndianIntType {
+        EndianIntType {
+            base: self.base.make_const(),
+            endian: self.endian,
+            size: self.size,
+            signed: self.signed,
+        }
+    }
+    pub fn equivalent(&self, other: &Self) -> bool {
+        self.base.equivalent(&other.base)
+            && self.endian == other.endian
+            && self.size == other.size
+            && self.signed == other.signed
+    }
+}
+
+impl DescribableType for EndianIntType {
+    fn describe(&self) -> String {
+        format!("{}int{}_{}_t",
+                if self.signed {
+                    ""
+                } else {
+                    "u"
+                },
+                self.size,
+                self.endian.short_desc(),
+        )
+    }
+}
+
+// Some types have differing sizes depending on operating system
+// Here we list currently tracked operating systems
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash, Ord, PartialOrd)]
+pub enum OSVariant {
+    Win64,
+    Win32,
+    Lin64,
+    Lin32,
+    Other,
+}
+
+impl OSVariant {
+    // User-friendly (moderately) description
+    pub fn describe(&self) -> &'static str {
+        match self {
+            OSVariant::Win64 => "64b windows",
+            OSVariant::Win32 => "32b windows",
+            OSVariant::Lin64 => "64b linux",
+            OSVariant::Lin32 => "32b linux",
+            OSVariant::Other => "unknown",
+        }
+    }
+}
+
+// Invariant: All VariantSizeMap should contain the 'Other' key
+#[derive(Debug, Clone, Hash, Eq, PartialEq, Ord, PartialOrd)]
+pub struct VariantSizeMap(BTreeMap<OSVariant,u16>);
+
+impl VariantSizeMap {
+    pub fn simple_size(size: u16) -> VariantSizeMap {
+        let mut hm: BTreeMap<OSVariant, u16> = BTreeMap::default();
+        hm.insert(OSVariant::Other, size);
+        VariantSizeMap(hm)
+    }
+
+    pub fn new<const N: usize>(
+        default_size: u16,
+        other_sizes: [(OSVariant, u16); N]) -> VariantSizeMap {
+        let mut hm: BTreeMap<OSVariant, u16> = BTreeMap::default();
+        hm.insert(OSVariant::Other, default_size);
+        for (var, size) in other_sizes {
+            if hm.contains_key(&var) {
+                error!("Internal Error: Attempting to create a variant size \
+                        with duplicate key {:?} (duplicate discarded)", var);
+                continue;
+            }
+            hm.insert(var, size);
+        }
+        VariantSizeMap(hm)
+    }
+
+    // Returns the OSVariants for which the sizes are different
+    fn compare_size(&self, other: &VariantSizeMap) -> Vec<OSVariant> {
+        let mut conflicting_sizes: Vec<OSVariant> = Vec::default();
+
+        for (var, sz) in &self.0 {
+            let cmp_with = if !other.0.contains_key(var) {
+                OSVariant::Other
+            } else {
+                *var
+            };
+            // Guaranteed by if check + invariant
+            if sz != other.0.get(&cmp_with).unwrap() {
+                conflicting_sizes.push(*var);
+            }
+        }
+        for (var, sz) in &other.0 {
+            // Already checked
+            if self.0.contains_key(var) {
+                continue;
+            }
+            // Guaranteed by invariant
+            if sz != self.0.get(&OSVariant::Other).unwrap() {
+                conflicting_sizes.push(*var);
+            }
+        }
+        conflicting_sizes
+    }
+
+    pub fn compare_size_with_fixed(&self, other: u16) -> Vec<OSVariant> {
+        let mut conflicting_sizes: Vec<OSVariant> = Vec::default();
+
+        for (var, sz) in &self.0 {
+           if sz != &other {
+                conflicting_sizes.push(*var);
+            }
+        }
+        conflicting_sizes
+    }
+
+    pub fn compare_with_int<T>(&self, other: T) -> Vec<OSVariant>
+    where T: Into<u16> {
+        self.compare_size_with_fixed(other.into())
+    }
+}
+
+// Ordering a variantsizemap is not entirely well defined,
+// - Inheriting from eq, A == B iff there are no conflicting sizes
+// - A > B iff
+//   for every size S in A, if the corresponding key exists in B, A(S) > B(S)
+//                          if it does not A(S) > B(OTHER)
+//   for every size S in B, if the corresponding key exists in B, A(S) < B(S)
+//                          if it does not B(S) < A(OTHER)
+// Similarly for B < A
+// For inconsistent sizes (there is a S1 and S2 so that A(S1) > B(S1)
+//                         and A(S2) < B(S2))
+// this returns None
+// These functions are similar to the ones provided by
+// Ord and Eq, however we will use the std:: ones for content-based
+// equality and ordering for containers, and these for semantics
+impl VariantSizeMap {
+    pub fn equal(&self, other: &Self) -> bool {
+        self.compare_size(other).is_empty()
+    }
+    pub fn compare(&self, other: &Self) -> Option<Ordering> {
+        let mut can_be_larger = true;
+        let mut can_be_smaller = true;
+        let mut is_equal = true;
+        for (var, sz) in &self.0 {
+            let cmp_with = if !other.0.contains_key(var) {
+                OSVariant::Other
+            } else {
+                *var
+            };
+            // Guaranteed by if check + invariant
+            let cmp = sz.cmp(other.0.get(&cmp_with).unwrap());
+            if cmp.is_ne() {
+                is_equal = false;
+            }
+            match cmp {
+                Ordering::Less => can_be_larger = false,
+                Ordering::Greater => can_be_smaller = false,
+                _ => (),
+            }
+        }
+        for (var, sz) in &other.0 {
+            // Already checked
+            if self.0.contains_key(var) {
+                continue;
+            }
+            // Guaranteed by invariant
+            let cmp = self.0.get(&OSVariant::Other).unwrap().cmp(sz);
+            if cmp.is_ne() {
+                is_equal = false;
+            }
+            match cmp {
+                Ordering::Less => can_be_larger = false,
+                Ordering::Greater => can_be_smaller = false,
+                _ => (),
+            }
+        }
+        if is_equal {
+            return Some(Ordering::Equal);
+        }
+        match (can_be_larger, can_be_smaller) {
+            (true, true) => unreachable!(
+                "INTERNAL LOGIC ERROR: Comparison of VariantSizeMap gave \
+                 impossible result between {:?} and {:?}",
+                self, other),
+            (true, false) => Some(Ordering::Greater),
+            (false, true) => Some(Ordering::Less),
+            _ => None,
+        }
+    }
+}
+
+
+impl_trait_fns!(IntType, DeclarationSpan, base, fn span(&self) -> &ZeroSpan);
+#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
+pub struct IntType {
+    base: TypeBase,
+    size: VariantSizeMap,
+    signed: bool,
+}
+
+impl IntType {
+    fn make_const(self) -> IntType {
+        IntType {
+            base: self.base.make_const(),
+            size: self.size,
+            signed: self.signed,
+        }
+    }
+    pub fn equivalent(&self, other: &Self) -> bool {
+        self.base.equivalent(&other.base)
+            && self.size == other.size
+            && self.signed == other.signed
+    }
+}
+
+impl IntType {
+    pub fn char(base: TypeBase) -> IntType {
+        IntType {
+            base,
+            signed: true,
+            size: VariantSizeMap::simple_size(8),
+        }
+    }
+    pub fn int(base: TypeBase, signed: bool) -> IntType {
+        IntType {
+            base,
+            signed,
+            size: VariantSizeMap::simple_size(32),
+        }
+    }
+
+    pub fn int64(base: TypeBase, signed: bool) -> IntType {
+        IntType {
+            base,
+            signed,
+            size: VariantSizeMap::simple_size(64),
+        }
+    }
+
+    pub fn long(base: TypeBase, signed: bool) -> IntType {
+        IntType {
+            base,
+            signed,
+            size: VariantSizeMap::new(
+                64,
+                [(OSVariant::Win64, 32),
+                 (OSVariant::Win32, 32)])
+        }
+    }
+    pub fn size_t(base: TypeBase, signed: bool) -> IntType {
+        IntType {
+            base,
+            signed,
+            size: VariantSizeMap::simple_size(64),
+        }
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Hash)]
+pub struct FloatType(TypeBase);
+impl_simple_from!(TypeBase, FloatType);
+impl_trait_fns!(FloatType, DeclarationSpan, 0, fn span(&self) -> &ZeroSpan);
+impl FloatType {
+    fn make_const(self) -> FloatType {
+        FloatType(self.0.make_const())
+    }
+    pub fn equivalent(&self, other: &Self) -> bool {
+        self.0.equivalent(&other.0)
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Hash)]
+pub struct DoubleType(TypeBase);
+impl_simple_from!(TypeBase, DoubleType);
+impl_trait_fns!(DoubleType, DeclarationSpan, 0, fn span(&self) -> &ZeroSpan);
+impl DoubleType {
+    fn make_const(self) -> DoubleType {
+        DoubleType(self.0.make_const())
+    }
+    pub fn equivalent(&self, other: &Self) -> bool {
+        self.0.equivalent(&other.0)
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Hash)]
+pub struct UnresolvedArrayType {
+    base: TypeBase,
+    size: Option<Expression>,
+    unresolved: Box<UnresolvedType>,
+}
+impl_trait_fns!(UnresolvedArrayType, DeclarationSpan, base, fn span(&self) -> &ZeroSpan);
+impl UnresolvedArrayType {
+    fn make_const(self) -> Self {
+        UnresolvedArrayType {
+            base: self.base.make_const(),
+            size: self.size,
+            unresolved: self.unresolved,
+        }
+    }
+}
+impl ResolveableType for UnresolvedArrayType {
+    fn resolve(&self, global_info: &mut GlobalTypeStorage,
+              resolving: &mut ResolvingState,
+              is_extern: bool, via_indirection: bool,
+              errors: &mut Vec<DMLError>) -> DMLType {
+        DMLConcreteType::Array(concrete_types::DMLArrayType {
+            base: self.base.clone(),
+            // TODO: Expression-to-constant
+            size: None,
+            typing: self.unresolved.resolve(global_info, resolving, is_extern, via_indirection, errors),
+        }).into()
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Hash)]
+pub struct UnresolvedPointerType {
+    base: TypeBase,
+    unresolved: Box<UnresolvedType>,
+}
+impl_trait_fns!(UnresolvedPointerType, DeclarationSpan, base, fn span(&self) -> &ZeroSpan);
+impl UnresolvedPointerType {
+    fn make_const(self) -> Self {
+        UnresolvedPointerType {
+            base: self.base.make_const(),
+            unresolved: self.unresolved,
+        }
+    }
+}
+impl ResolveableType for UnresolvedPointerType {
+    fn resolve(&self, global_info: &mut GlobalTypeStorage,
+              resolving: &mut ResolvingState,
+              is_extern: bool, _via_indirection: bool,
+              errors: &mut Vec<DMLError>) -> DMLType {
+        DMLConcreteType::Pointer(concrete_types::DMLPointerType {
+            base: self.base.clone(),
+            typing: self.unresolved.resolve(global_info, resolving, is_extern, true, errors),
+        }).into()
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Hash)]
+pub struct UnresolvedFunctionType {
+    base: TypeBase,
+    return_type: Box<UnresolvedType>,
+    argument_types: Vec<UnresolvedType>,
+    varargs: bool,
+}
+impl_trait_fns!(UnresolvedFunctionType, DeclarationSpan, base, fn span(&self) -> &ZeroSpan);
+impl UnresolvedFunctionType {
+    fn make_const(self) -> Self {
+        UnresolvedFunctionType {
+            base: self.base.make_const(),
+            return_type: self.return_type,
+            argument_types: self.argument_types,
+            varargs: self.varargs,
+        }
+    }
+}
+impl ResolveableType for UnresolvedFunctionType {
+    fn resolve(&self, global_info: &mut GlobalTypeStorage,
+              resolving: &mut ResolvingState,
+              is_extern: bool, via_indirection: bool,
+              errors: &mut Vec<DMLError>) -> DMLType {
+        DMLConcreteType::Function(
+            concrete_types::DMLFunctionType {
+                base: self.base.clone(),
+                arg_types: self.argument_types.iter()
+                    .map(|t|t.resolve(global_info, resolving, is_extern, via_indirection, errors))
+                    .collect(),
+                vararg: self.varargs,
+                return_ty: self.return_type.resolve(global_info, resolving, is_extern, via_indirection, errors),
+        }).into()
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Hash)]
+pub struct UnresolvedVectorType {
+    base: TypeBase,
+    unresolved: Box<UnresolvedType>
+}
+impl_trait_fns!(UnresolvedVectorType, DeclarationSpan, base, fn span(&self) -> &ZeroSpan);
+impl UnresolvedVectorType {
+    fn make_const(self) -> Self {
+        UnresolvedVectorType {
+            base: self.base.make_const(),
+            unresolved: self.unresolved,
+        }
+    }
+}
+impl ResolveableType for UnresolvedVectorType {
+    fn resolve(&self, global_info: &mut GlobalTypeStorage,
+              resolving: &mut ResolvingState,
+              is_extern: bool, _via_indirection: bool,
+              errors: &mut Vec<DMLError>) -> DMLType {
+        DMLConcreteType::Vector(concrete_types::DMLVectorType {
+            base: self.base.clone(),
+            typing: self.unresolved.resolve(global_info, resolving, is_extern, true, errors),
+        }).into()
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Hash)]
+pub struct BitSlice {
+    pub lsb: Option<Expression>,
+    pub msb: Option<Expression>,
+    pub typing: IntType,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Hash)]
+pub struct BitfieldsType {
+    pub base: TypeBase,
+    pub sizing: u8,
+    pub members: Vec<(DMLString, BitSlice)>,
+}
+impl_trait_fns!(BitfieldsType, DeclarationSpan, base, fn span(&self) -> &ZeroSpan);
+impl ResolveableType for BitfieldsType {
+    fn resolve(&self, _global_info: &mut GlobalTypeStorage,
+              _resolving: &mut ResolvingState,
+              _is_extern: bool, _via_indirection: bool,
+              _errors: &mut Vec<DMLError>) -> DMLType {
+        DMLConcreteType::Bitfields(self.clone()).into()
+    }
+}
+impl BitfieldsType {
+    fn make_const(self) -> BitfieldsType {
+        BitfieldsType {
+            base: self.base.make_const(),
+            sizing: self.sizing,
+            members: self.members,
+        }
+    }
+    pub fn equivalent(&self, other: &Self) -> bool {
+        self.base.equivalent(&other.base)
+            && self.sizing == other.sizing
+            && self.members.len() == other.members.len()
+            && self.members.iter().zip(other.members.iter())
+            .all(|((i1_name, i1_bitslice), (i2_name, i2_bitslice))|
+                 i1_name.val == i2_name.val
+                 && i1_bitslice == i2_bitslice)
+    }
+}
+
+fn ast_to_bitfield<'a>(content: &types::BitfieldsContent,
+                       report: &mut Vec<LocalDMLError>,
+                       file: FileSpec<'a>) -> UnresolvedType {
+    let mut sizing = content.iconst.read_leaf(file.file)
+        // Should be guaranteed by parser
+        .map(|s|s.as_str().parse::<i64>().unwrap())
+        // Default to largest available size if the token was missing
+        .unwrap_or(64);
+    if sizing > 64 {
+        report.push(LocalDMLError {
+            range: content.iconst.range(),
+            description: "Bitfields size cannot be > than 64 bits".to_string(),
+        });
+        sizing = 64;
+    } else if sizing < 1 {
+        report.push(LocalDMLError {
+            range: content.iconst.range(),
+            description: "Bitfields size cannot be less than 1".to_string(),
+        });
+        sizing = 1;
+    };
+    let sizing = sizing as u8;
+    fn content_to_bitslice<'a>(content: &types::BitfieldsDeclContent,
+                               _bitfield_size: u8,
+                               report: &mut Vec<LocalDMLError>,
+                               file: FileSpec<'a>)
+                               -> Option<(DMLString, BitSlice)> {
+        let (name, typing) = deconstruct_cdecl(content.cdecl.as_actual()?,
+                                               report,
+                                               file);
+        let (lsb, msb) = match &content.range {
+            types::BitfieldsRange::Expression(expr) => {
+                let expression = ExpressionKind::to_expression(expr, report, file);
+                (expression.clone(), expression)
+            },
+            types::BitfieldsRange::Range(msb, _, lsb) =>
+                (ExpressionKind::to_expression(msb, report,file),
+                 ExpressionKind::to_expression(lsb, report,file)),
+        };
+        let UnresolvedType::Int(inttype) = typing else {
+            report.push(LocalDMLError {
+                range: typing.span().range,
+                description:
+                    "Bitfield type must be simple integer type".to_string(),
+            });
+            return None;
+        };
+        // TODO: verify that LSB and MSB are constant expressions through
+        // constant-folding, and verify that their size matches typing
+        // and that they are in-bounds for the bitfields
+        Some(
+            // We can discard unnamed fields at this point, since nothing will
+            // refer to them
+            (name?,
+             BitSlice {
+                 lsb, msb, typing: inttype,
+             })
+        )
+    }
+
+    let members = content.fields.iter()
+        .filter_map(|content|content_to_bitslice(content, sizing, report, file))
+        .collect();
+    UnresolvedType::Bitfields(BitfieldsType {
+        base: TypeBase::from_span(
+            ZeroSpan::from_range(content.range(), file.path)),
+        sizing,
+        members,
+    })
+}
+
+// Some labels are internally auto-generated, and thus do not have a span
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Hash)]
+pub struct Label {
+    name: String,
+    span: Option<ZeroSpan>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Hash)]
+pub struct UnresolvedStructType {
+    pub base: TypeBase,
+    pub members: Vec<(Option<DMLString>, UnresolvedType)>,
+}
+impl_trait_fns!(UnresolvedStructType, DeclarationSpan, base, fn span(&self) -> &ZeroSpan);
+impl ResolveableType for UnresolvedStructType {
+    // NOTE: struct types resolved in this way are always anonymous, when we 'resolve' a proper typedeffed
+    // struct type we will add the proper label
+    fn resolve(&self, global_info: &mut GlobalTypeStorage,
+              resolving: &mut ResolvingState,
+              is_extern: bool, via_indirection: bool,
+              errors: &mut Vec<DMLError>) -> DMLType {
+        DMLConcreteType::StructType(
+            self.resolve_to_struct(None, global_info, resolving,
+                                   is_extern, via_indirection, errors))
+            .into()
+    }
+}
+
+impl UnresolvedStructType {
+    fn resolve_to_struct(&self, label: Option<DMLString>, global_info: &mut GlobalTypeStorage,
+                        resolving: &mut ResolvingState,
+                        is_extern: bool, via_indirection: bool,
+                        errors: &mut Vec<DMLError>)
+    -> concrete_types::DMLStructType {
+        concrete_types::DMLStructType {
+            label: DMLStructLabel::new_from_maybe_string(label),
+            base: self.base.clone(),
+            members: self.members.iter()
+                .map(|(name, t)| {
+                    (name.clone(),
+                     t.resolve(global_info, resolving, is_extern, via_indirection, errors))
+                })
+                .collect(),
+        }
+    }
+    fn make_const(self) -> UnresolvedStructType {
+        UnresolvedStructType {
+            base: self.base.make_const(),
+            members: self.members,
+        }
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Hash)]
+pub struct UnresolvedLayoutType {
+    pub base: UnresolvedStructType,
+    pub endianness: Option<Endianness>,
+}
+impl_trait_fns!(UnresolvedLayoutType, DeclarationSpan,
+                base, fn span(&self) -> &ZeroSpan);
+impl ResolveableType for UnresolvedLayoutType {
+    fn resolve(&self, global_info: &mut GlobalTypeStorage,
+              resolving: &mut ResolvingState,
+              is_extern: bool, via_indirection: bool,
+              errors: &mut Vec<DMLError>) -> DMLType {
+        DMLConcreteType::Layout(
+            concrete_types::DMLLayoutType {
+                base: self.base.resolve_to_struct(None, global_info, resolving,
+                                                   is_extern, via_indirection, errors),
+                endianness: self.endianness.clone(),
+        }).into()
+    }
+}
+impl UnresolvedLayoutType {
+    fn make_const(self) -> UnresolvedLayoutType {
+        UnresolvedLayoutType {
+            base: self.base.make_const(),
+            endianness: self.endianness,
+        }
+    }
+}
+
+
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Hash)]
+pub struct UnresolvedSequenceType {
+    pub base: TypeBase,
+    pub trait_name: NamedType,
+}
+impl_trait_fns!(UnresolvedSequenceType, DeclarationSpan,
+                base, fn span(&self) -> &ZeroSpan);
+impl ResolveableType for UnresolvedSequenceType {
+    fn resolve(&self, global_info: &mut GlobalTypeStorage,
+              resolving: &mut ResolvingState,
+              is_extern: bool, via_indirection: bool,
+              errors: &mut Vec<DMLError>) -> DMLType {
+        let resolved = global_info.resolve_named(
+            &self.trait_name, resolving, is_extern, via_indirection, errors);
+        match resolved.as_deref() {
+            Some(DMLConcreteType::Trait(trait_type)) =>
+                DMLConcreteType::Sequence(concrete_types::DMLSequenceType {
+                    base: self.base.clone(),
+                    trait_type: trait_type.clone(),
+                }).into(),
+            Some(_) => {
+                errors.push(DMLError {
+                    span: self.trait_name.name.span,
+                    description: format!(
+                        "'{}' is not a template, and cannot be \
+                         used in 'sequence(...)'", self.trait_name.name.val),
+                    related: vec![],
+                    severity: Some(DiagnosticSeverity::ERROR),
+                });
+                None
+            },
+            // resolve_named() already reported an "unknown type" error
+            None => None,
+        }
+    }
+}
+impl UnresolvedSequenceType {
+    fn make_const(self) -> UnresolvedSequenceType {
+        UnresolvedSequenceType {
+            base: self.base.make_const(),
+            trait_name: self.trait_name,
+        }
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Hash)]
+pub struct UnresolvedHookType {
+    pub base: TypeBase,
+    pub arg_types: Vec<UnresolvedType>,
+}
+impl_trait_fns!(UnresolvedHookType, DeclarationSpan,
+                base, fn span(&self) -> &ZeroSpan);
+impl ResolveableType for UnresolvedHookType {
+    fn resolve(&self, global_info: &mut GlobalTypeStorage,
+              resolving: &mut ResolvingState,
+              is_extern: bool, via_indirection: bool,
+              errors: &mut Vec<DMLError>) -> DMLType {
+        DMLConcreteType::Hook(
+            concrete_types::DMLHookType {
+                base: self.base.clone(),
+                arg_types: self.arg_types.iter()
+                    .map(|t|t.resolve(global_info, resolving, is_extern, via_indirection, errors))
+                    .collect(),
+        }).into()
+    }
+}
+impl UnresolvedHookType {
+    fn make_const(self) -> UnresolvedHookType {
+        UnresolvedHookType {
+            base: self.base.make_const(),
+            arg_types: self.arg_types,
+        }
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Hash)]
+pub struct UnresolvedTypeOf {
+    pub base: TypeBase,
+    pub of: Expression,
+}
+impl_trait_fns!(UnresolvedTypeOf, DeclarationSpan,
+                base, fn span(&self) -> &ZeroSpan);
+impl ResolveableType for UnresolvedTypeOf {
+    fn resolve(&self, _global_info: &mut GlobalTypeStorage,
+              _resolving: &mut ResolvingState,
+              _is_extern: bool, _via_indirection: bool,
+              _errors: &mut Vec<DMLError>) -> DMLType {
+        // TODO: Figure out the type on an expression
+        DMLType::None
+    }
+}
+impl UnresolvedTypeOf {
+    fn make_const(self) -> UnresolvedTypeOf {
+        UnresolvedTypeOf {
+            base: self.base.make_const(),
+            of: self.of,
+        }
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Hash)]
+pub enum UnresolvedType {
+    // NOTE: Named types here may be further resolved later during resolution,
+    // especially notable for trait types
+    Named(NamedType),
+    Device(DeviceType),
+    Bool(BoolType),
+    EndianInt(EndianIntType),
+    Int(IntType),
+    Float(FloatType),
+    Double(DoubleType),
+    Array(UnresolvedArrayType),
+    Pointer(UnresolvedPointerType),
+    Function(UnresolvedFunctionType),
+    Vector(UnresolvedVectorType),
+    Bitfields(BitfieldsType),
+    Struct(UnresolvedStructType),
+    Layout(UnresolvedLayoutType),
+    Sequence(UnresolvedSequenceType),
+    Hook(UnresolvedHookType),
+    TypeOf(UnresolvedTypeOf),
+    Void(VoidType),
+    // For types that fail to resolve for whatever reason, but we still
+    // need to hold a type for. The span is the decl span of the type,
+    // the vector is valid (or invalid) subtypes it might contain
+    // For example void (*)(*) would be a pointer to a function type
+    // returning void with one argument that is a pointer to an invalid
+    // type
+    Invalid(ZeroSpan),
+}
+
+impl UnresolvedType {
+    pub fn make_invalid(span: ZeroSpan) -> Self {
+        Self::Invalid(span)
+    }
+    pub fn make_const(self) -> Self {
+        match self {
+            Self::Named(i) => Self::Named(i.make_const()),
+            Self::Device(i) => Self::Device(i.make_const()),
+            Self::Bool(i) => Self::Bool(i.make_const()),
+            Self::EndianInt(i) => Self::EndianInt(i.make_const()),
+            Self::Int(i) => Self::Int(i.make_const()),
+            Self::Float(i) => Self::Float(i.make_const()),
+            Self::Double(i) => Self::Double(i.make_const()),
+            Self::Array(i) => Self::Array(i.make_const()),
+            Self::Pointer(i) => Self::Pointer(i.make_const()),
+            Self::Function(i) => Self::Function(i.make_const()),
+            Self::Vector(i) => Self::Vector(i.make_const()),
+            Self::Struct(i) => Self::Struct(i.make_const()),
+            Self::Bitfields(i) => Self::Bitfields(i.make_const()),
+            Self::Layout(i) => Self::Layout(i.make_const()),
+            Self::Sequence(i) => Self::Sequence(i.make_const()),
+            Self::Hook(i) => Self::Hook(i.make_const()),
+            Self::TypeOf(i) => Self::TypeOf(i.make_const()),
+            // This is a funny, but valid, type
+            Self::Void(i) => Self::Void(i.make_const()),
+            invalid @ Self::Invalid(_) => invalid,
+        }
+    }
+}
+
+impl DeclarationSpan for UnresolvedType {
+    fn span(&self) -> &ZeroSpan {
+        match self {
+            Self::Named(i) => i.span(),
+            Self::Device(i) => i.span(),
+            Self::Bool(i) => i.span(),
+            Self::EndianInt(i) => i.span(),
+            Self::Int(i) => i.span(),
+            Self::Float(i) => i.span(),
+            Self::Double(i) => i.span(),
+            Self::Array(i) => i.span(),
+            Self::Pointer(i) => i.span(),
+            Self::Function(i) => i.span(),
+            Self::Vector(i) => i.span(),
+            Self::Struct(i) => i.span(),
+            Self::Bitfields(i) => i.span(),
+            Self::Layout(i) => i.span(),
+            Self::Sequence(i) => i.span(),
+            Self::Hook(i) => i.span(),
+            Self::TypeOf(i) => i.span(),
+            Self::Void(i) => i.span(),
+            Self::Invalid(s) => s,
+        }
+    }
+}
+
+impl ResolveableType for UnresolvedType {
+    fn resolve(&self, global_info: &mut GlobalTypeStorage,
+              resolving: &mut ResolvingState,
+              is_extern: bool, via_indirection: bool,
+              errors: &mut Vec<DMLError>) -> DMLType {
+        match self {
+            Self::Device(i) => DMLConcreteType::Device(i.clone()).into(),
+            Self::Bool(i) => DMLConcreteType::Bool(i.clone()).into(),
+            Self::EndianInt(i) => DMLConcreteType::EndianInt(i.clone()).into(),
+            Self::Int(i) => DMLConcreteType::Int(i.clone()).into(),
+            Self::Float(i) => DMLConcreteType::Float(i.clone()).into(),
+            Self::Double(i) => DMLConcreteType::Double(i.clone()).into(),
+            Self::Void(i) => DMLConcreteType::Void(i.clone()).into(),
+            Self::Named(i) => i.resolve(global_info, resolving, is_extern, via_indirection, errors),
+            Self::Array(i) => i.resolve(global_info, resolving, is_extern, via_indirection, errors),
+            Self::Pointer(i) => i.resolve(global_info, resolving, is_extern, via_indirection, errors),
+            Self::Function(i) => i.resolve(global_info, resolving, is_extern, via_indirection, errors),
+            Self::Vector(i) => i.resolve(global_info, resolving, is_extern, via_indirection, errors),
+            Self::Struct(i) => i.resolve(global_info, resolving, is_extern, via_indirection, errors),
+            Self::Bitfields(i) => i.resolve(global_info, resolving, is_extern, via_indirection, errors),
+            Self::Layout(i) => i.resolve(global_info, resolving, is_extern, via_indirection, errors),
+            Self::Sequence(i) => i.resolve(global_info, resolving, is_extern, via_indirection, errors),
+            Self::Hook(i) => i.resolve(global_info, resolving, is_extern, via_indirection, errors),
+            Self::TypeOf(i) => i.resolve(global_info, resolving, is_extern, via_indirection, errors),
+            Self::Invalid(_) => None,
+        }
+    }
+}
+
+// Returns the (binding name, type) of the typedecl
+#[allow(clippy::ptr_arg)]
 pub fn deconstruct_typedecl<'a>(
     content: &misc::TypeDeclContent,
-    _report: &mut Vec<LocalDMLError>,
-    file: FileSpec<'a>) -> (Option<DMLString>, Option<DMLType>) {
-    // TODO: Correctly combine info from cdecl with this to construct actual
-    // type. Currently we just faux the type location as the entire typedecl
-    match content {
+    outside_type: UnresolvedType,
+    report: &mut Vec<LocalDMLError>,
+    file: FileSpec<'a>) -> (Option<DMLString>,
+                            Option<UnresolvedType>) {
+    // TODO/NOTE: Careful thought needs to be put into the failure
+    // modes of this function
+    // inner_decl = typedeclcontent to further handle
+    // new_ident = identifier from inner handling
+    // inner_type = type after inner handling
+    let (inner_decl, new_ident, inner_type) = match content {
         misc::TypeDeclContent::Ident(tok) =>
-            (DMLString::from_token(tok, file),
-             Some(ZeroSpan::from_range(content.range(), file.path))),
-        misc::TypeDeclContent::Array(inner_decl, _, _, _) =>
-            match &inner_decl.content {
-                Some(inner_decl_obj) => {
-                    // TODO: array the type
-                    inner_decl_obj.with_content(
-                        |con|deconstruct_typedecl(con, _report, file),
-                    (None, None))
-                },
-                None => (None, Some(ZeroSpan::from_range(content.range(),
+            (None, DMLString::from_token(tok, file), outside_type),
+        misc::TypeDeclContent::Array(inner_decl, _, size, _) =>
+            (Some(inner_decl),
+             None,
+             UnresolvedType::Array(UnresolvedArrayType {
+                 unresolved: Box::new(outside_type),
+                 size: ExpressionKind::to_expression(size, report, file),
+                 base: TypeBase::from_span(
+                     ZeroSpan::from_range(content.range(), file.path)),
+             })),
+        misc::TypeDeclContent::Fun(inner_decl, _, args, varargs, _) => {
+            let unresolved_args =
+                cdecls_to_members(args.iter().map(|(cdecl,_)|cdecl),
+                                  report, file)
+                .into_iter().map(|(_,arg_type)|arg_type)
+                .collect();
+            (Some(inner_decl),
+             None,
+             UnresolvedType::Function(UnresolvedFunctionType {
+                 return_type: Box::new(outside_type),
+                 argument_types: unresolved_args,
+                 varargs: varargs.is_some(),
+                 base: TypeBase::from_span(
+                     ZeroSpan::from_range(content.range(), file.path)),
+             }))
+        },
+        misc::TypeDeclContent::Parens(_, modifiers, inner_decl, _) => {
+            let mut modified_outer = outside_type;
+            for modifier in modifiers {
+                // Should be unable to fail based on parsing rules
+                match modifier.get_token().unwrap().kind {
+                    TokenKind::Const =>
+                        modified_outer = modified_outer.make_const(),
+                    TokenKind::Multiply =>
+                        modified_outer = UnresolvedType::Pointer(
+                            UnresolvedPointerType {
+                                base: TypeBase::from_span(ZeroSpan::combine(
+                                    *modified_outer.span(),
+                                    ZeroSpan::from_range(modifier.range(),
                                                          file.path))),
-            },
-        misc::TypeDeclContent::Fun(inner_decl, _, _, _, _) =>
-            match &inner_decl.content {
-                Some(inner_decl_obj) => {
-                    // TODO: convert to actual function type
-                    inner_decl_obj.with_content(
-                        |con|deconstruct_typedecl(con, _report, file),
-                    (None, None))
-                },
-                None => (None, Some(
-                    ZeroSpan::from_range(content.range(),
-                                         file.path))),
-            },
-        misc::TypeDeclContent::Parens(_, _, inner_decl, _) =>
-            match &inner_decl.content {
-                Some(inner_decl_obj) => {
-                    // TODO: modify with in-parens modifiers
-                    inner_decl_obj.with_content(
-                        |con|deconstruct_typedecl(con, _report, file),
-                    (None, None))
-                },
-                None => (None, Some(ZeroSpan::from_range(content.range(),
+                                unresolved: Box::new(modified_outer),
+                            }),
+                    TokenKind::Vect =>
+                        modified_outer = UnresolvedType::Vector(
+                            UnresolvedVectorType {
+                                base: TypeBase::from_span(ZeroSpan::combine(
+                                    *modified_outer.span(),
+                                    ZeroSpan::from_range(modifier.range(),
                                                          file.path))),
-            },
+                                unresolved: Box::new(modified_outer),
+                            }),
+                    _ => internal_error!(
+                        "Unexpected token in cdecl modifier list: \
+                         {:?}", modifier.read_leaf(file.file).unwrap()),
+                }
+            }
+            (Some(inner_decl), None, modified_outer)
+        },
+    };
+    if let Some(decl) = inner_decl {
+        if let Some(inner_content) = &decl.content {
+            deconstruct_typedecl(
+                inner_content.as_actual()
+                    .expect("Inner cdecl was some-d but missing."),
+                inner_type,
+                report,
+                file)
+        } else {
+            // TODO: is this a syntax error?
+            (new_ident, Some(inner_type))
+        }
+    } else {
+        (new_ident, Some(inner_type))
+    }
+}
+
+#[allow(clippy::ptr_arg)]
+fn name_to_integer<'a>(name: &str,
+                       leaf: &LeafToken,
+                       _report: &mut Vec<LocalDMLError>,
+                       file: FileSpec<'a>) -> Option<UnresolvedType> {
+    lazy_static! {
+        static ref INT_RE: Regex =
+            Regex::new(r"(u?)int([1-5][0-9]?|6[0-4]?|[789])(_be_t|_le_t)?$")
+            .unwrap();
+    }
+    if let Some(captures) = INT_RE.captures(name) {
+        let signed = captures.get(1).is_none();
+        let size = match captures.get(2).unwrap()
+            .as_str().parse::<u16>()
+        {
+            Ok(s) => s,
+            Err(e) => {
+                error!("Internal Error: Wanted to parse '{}' to integer in \
+                        type, but couldnt. {:?}",
+                       captures.get(2).unwrap().as_str(), e);
+                return None;
+            }
+        };
+        let endianness = captures.get(3).map(
+            |en|if en.as_str() == "be_t" { Endianness::BE }
+            else { Endianness::LE });
+        if let Some(en) = endianness {
+            Some(UnresolvedType::EndianInt(EndianIntType {
+                base: TypeBase::from_leaf(leaf, file),
+                endian: en,
+                size,
+                signed,
+            }))
+        } else {
+            Some(UnresolvedType::Int(IntType {
+                base: TypeBase::from_leaf(leaf, file),
+                size: VariantSizeMap::simple_size(size),
+                signed,
+            }))
+        }
+    } else {
+        None
+    }
+}
+
+pub fn name_to_primitive_or_named<'a>(leaf: &LeafToken,
+                                      report: &mut Vec<LocalDMLError>,
+                                      file: FileSpec<'a>)
+                                      -> Option<UnresolvedType> {
+    let name = leaf.read_leaf(file.file)?;
+    // NOTE: Some built-in types not mentioned here are defined as
+    // built-in named types instead
+    // NOTE/TODO: In simics 7, there is an integer_t type available
+    Some(match name.as_str() {
+        "void" => UnresolvedType::Void(TypeBase::from_leaf(leaf, file).into()),
+        "bool" => UnresolvedType::Bool(TypeBase::from_leaf(leaf, file).into()),
+        "float" => UnresolvedType::Float(
+            TypeBase::from_leaf(leaf, file).into()),
+        "double" => UnresolvedType::Double(
+            TypeBase::from_leaf(leaf, file).into()),
+        _ => if let Some(typ) = name_to_integer(
+            name.as_str(), leaf, report, file) {
+            typ
+        } else {
+            UnresolvedType::Named(NamedType {
+                base: TypeBase::from_leaf(leaf, file),
+                // Guaranteed by the read above
+                name: DMLString::from_token(leaf, file).unwrap(),
+            })
+        }
+    })
+}
+
+pub fn cdecls_to_members<'t, 'a, T>(i: T,
+                                    report: &mut Vec<LocalDMLError>,
+                                    file: FileSpec<'a>)
+                                    -> Vec<(Option<DMLString>, UnresolvedType)>
+where
+    T: Iterator<Item = &'t misc::CDecl>
+{
+    i.flat_map(misc::CDecl::as_actual)
+     .map(|cdecl|deconstruct_cdecl(cdecl, report, file))
+     .collect()
+}
+
+pub fn string_to_endianness(str: &str) -> Option<Endianness> {
+    match str {
+        r#""big-endian""# => Some(Endianness::BE),
+        r#""little-endian""# => Some(Endianness::LE),
+        _ => None,
+    }
+}
+
+fn ast_to_unresolved_layout<'a>(layout_ast: &types::LayoutContent,
+                                report: &mut Vec<LocalDMLError>,
+                                file: FileSpec<'a>)
+                                -> UnresolvedType {
+    let endianness = layout_ast.byteorder.read_leaf(file.file)
+        .as_deref()
+        .and_then(string_to_endianness);
+    let struct_base = ast_to_unresolved_struct_base(
+        &layout_ast.layout,
+        &layout_ast.rbrace,
+        &layout_ast.fields,
+        report,
+        file);
+    UnresolvedType::Layout(UnresolvedLayoutType {
+        base: struct_base,
+        endianness,
+    })
+}
+
+#[allow(clippy::ptr_arg)]
+fn ast_to_unresolved_struct_base<'a>(
+    token: &LeafToken,
+    rbrace: &LeafToken,
+    members: &Vec<(misc::CDecl, LeafToken)>,
+    report: &mut Vec<LocalDMLError>,
+    file: FileSpec<'a>) -> UnresolvedStructType {
+    let members = cdecls_to_members(
+        members.iter().map(|(cdecl,_)|cdecl),
+        report,
+        file);
+    let start = ZeroSpan::from_range(token.range(), file.path);
+    let end = ZeroSpan::from_range(rbrace.range(), file.path);
+    UnresolvedStructType {
+        base: TypeBase::from_span(ZeroSpan::combine(start, end)),
+        members,
+    }
+}
+
+fn ast_to_unresolved_struct<'a>(struct_ast: &types::StructTypeContent,
+                                report: &mut Vec<LocalDMLError>,
+                                file: FileSpec<'a>)
+                                -> Option<UnresolvedType> {
+    Some(UnresolvedType::Struct(ast_to_unresolved_struct_base(
+        &struct_ast.structtok,
+        &struct_ast.rbrace,
+        &struct_ast.members,
+        report, file)))
+}
+
+fn ast_to_unresolved_sequence<'a>(content: &types::SequenceContent,
+                                  _report: &mut Vec<LocalDMLError>,
+                                  file: FileSpec<'a>) -> UnresolvedType {
+    if let Some(name) = DMLString::from_token(&content.ident, file) {
+        return UnresolvedType::Sequence(
+            UnresolvedSequenceType {
+                trait_name: NamedType {
+                    base: TypeBase::from_leaf(&content.ident, file),
+                    name,
+                },
+                base: TypeBase::from_span(
+                    ZeroSpan::from_range(content.range(), file.path)),
+            });
+    }
+
+    UnresolvedType::make_invalid(
+        ZeroSpan::from_range(content.range(), file.path))
+}
+
+fn ast_to_unresolved_hook<'a>(content: &types::HookTypeContent,
+                              report: &mut Vec<LocalDMLError>,
+                              file: FileSpec<'a>) -> UnresolvedType {
+    UnresolvedType::Hook(UnresolvedHookType {
+        base: TypeBase::from_span(
+            ZeroSpan::from_range(content.range(), file.path)),
+        arg_types: content.args.iter()
+            .map(|(maybe_cdecl, _)| {
+                if let Some(cdecl) = maybe_cdecl.as_actual() {
+                    let (_name, typ) = deconstruct_cdecl(cdecl, report, file);
+                    // TODO: Do we need to check name here? Existence? Uniqueness?
+                    typ
+                } else {
+                    UnresolvedType::make_invalid(
+                        ZeroSpan::from_range(maybe_cdecl.range(), file.path))
+                }
+            })
+            .collect(),
+    })
+}
+
+fn ast_to_unresolved_typeof<'a>(content: &types::TypeOfContent,
+                                report: &mut Vec<LocalDMLError>,
+                                file: FileSpec<'a>) -> UnresolvedType {
+    if let Some(expr) = ExpressionKind::to_expression(
+                            &content.of, report, file) {
+        UnresolvedType::TypeOf(
+            UnresolvedTypeOf {
+                base: TypeBase::from_span(
+                    ZeroSpan::from_range(content.range(), file.path)),
+                of: expr,
+            })
+    } else {
+        UnresolvedType::make_invalid(
+            ZeroSpan::from_range(content.range(), file.path))
+    }
+}
+
+pub fn deconstruct_type<'a>(content: &types::BaseTypeContent,
+                            report: &mut Vec<LocalDMLError>,
+                            file: FileSpec<'a>) -> Option<UnresolvedType> {
+    match content {
+        types::BaseTypeContent::Ident(leaf) =>
+            name_to_primitive_or_named(leaf, report, file),
+        types::BaseTypeContent::Struct(struct_ast) =>
+            ast_to_unresolved_struct(struct_ast, report, file),
+        types::BaseTypeContent::Layout(layout_ast) =>
+            Some(ast_to_unresolved_layout(layout_ast, report, file)),
+        types::BaseTypeContent::Bitfields(bitfield_ast) =>
+            Some(ast_to_bitfield(bitfield_ast, report, file)),
+        types::BaseTypeContent::Sequence(sequence_ast) =>
+            Some(ast_to_unresolved_sequence(sequence_ast, report, file)),
+        types::BaseTypeContent::Hook(hook_ast) =>
+            Some(ast_to_unresolved_hook(hook_ast, report, file)),
+        types::BaseTypeContent::TypeOf(typeof_ast) =>
+            Some(ast_to_unresolved_typeof(typeof_ast, report, file)),
     }
 }
 
-// TODO: For now this does not need to obtain the actual type, only the name
-// of the declaration
 pub fn deconstruct_cdecl<'a>(content: &misc::CDeclContent,
                              report: &mut Vec<LocalDMLError>,
                              file: FileSpec<'a>) ->
-    (Option<DMLString>, Option<DMLType>) {
-    // let is_const = content.consttok.is_some();
-    // let base = TODO;
-    // let modififiers = TODO;
-    match &content.decl.content {
-        Some(typedeclobj) => {
-            // I _think_ a typedecl can never be an empty object, (since an
-            // empty typedecl will just become None)
-            typedeclobj.with_content(
-                |con|deconstruct_typedecl(con, report, file),
-                (None, None))
-        },
-        None => (None, Some(ZeroSpan::from_range(content.base.range(),
+    (Option<DMLString>, UnresolvedType)
+{
+    let mut base = content.base
+        .with_content(|c|deconstruct_type(c, report, file), None)
+        .unwrap_or_else(||UnresolvedType::make_invalid(
+            ZeroSpan::from_range(content.range(), file.path)));
+    if content.consttok.is_some() {
+        base = base.make_const()
+    }
+    for modifier in &content.modifiers {
+        // Should be unable to fail based on parsing rules
+        match modifier.get_token().unwrap().kind {
+            TokenKind::Const => base = base.make_const(),
+            TokenKind::Multiply => base = UnresolvedType::Pointer(
+                UnresolvedPointerType {
+                    base: TypeBase::from_span(ZeroSpan::combine(
+                        *base.span(),
+                        ZeroSpan::from_range(
+                            modifier.range(),
+                            file.path))),
+                    unresolved: Box::new(base),
+                }),
+            TokenKind::Vect =>
+                base = UnresolvedType::Vector(
+                    UnresolvedVectorType {
+                        base: TypeBase::from_span(ZeroSpan::combine(
+                            *base.span(),
+                            ZeroSpan::from_range(modifier.range(),
                                                  file.path))),
+                        unresolved: Box::new(base),
+                    }),
+            _ => internal_error!("Unexpected token in cdecl modifier list: \
+                                  {:?}",
+                                 modifier.read_leaf(file.file).unwrap()),
+        }
     }
+
+    let (name, typing) = content.decl.content.as_ref().map(|typedecl|{
+        // I _think_ a typedecl can never be an empty object, (since an
+        // empty typedecl will just become None)
+        deconstruct_typedecl(typedecl.as_actual().unwrap(),
+                             base, report, file)
+    }).unzip();
+    (name.flatten(),
+     typing.flatten().unwrap_or_else(||UnresolvedType::make_invalid(
+         ZeroSpan::from_range(content.range(), file.path))))
 }
 
+
 #[allow(clippy::ptr_arg)]
-pub fn to_type<'a>(content: &types::CTypeDecl,
-                   _report: &mut Vec<LocalDMLError>,
-                   file: FileSpec<'a>) -> Option<DMLType> {
-    content.with_content(|con|Some(ZeroSpan::from_range(con.range(),
-                                                        file.path)),
-                         None)
+pub fn to_type<'a>(maybe_content: &types::CTypeDecl,
+                   report: &mut Vec<LocalDMLError>,
+                   file: FileSpec<'a>) -> Option<UnresolvedType> {
+    let content = maybe_content.as_actual()?;
+    let mut base = content.base
+        .with_content(|c|deconstruct_type(c, report, file), None)
+        .unwrap_or_else(||UnresolvedType::make_invalid(
+            ZeroSpan::from_range(content.range(), file.path)));
+    if content.consttok.is_some() {
+        base = base.make_const();
+    }
+
+    fn modify_with_inner(mut b: UnresolvedType,
+                         maybe_inner: &CTypeDeclSimple,
+                         report: &mut Vec<LocalDMLError>,
+                         file: FileSpec<'_>) -> UnresolvedType {
+        let Some(inner) = maybe_inner.as_actual() else {
+            return b;
+        };
+        for modifier in &inner.modifiers {
+            // Guaranteed by parser
+            match modifier.get_token().unwrap().kind {
+                TokenKind::Const => b = b.make_const(),
+                TokenKind::Multiply => b = UnresolvedType::Pointer(
+                    UnresolvedPointerType {
+                        base: TypeBase::from_span(ZeroSpan::combine(
+                            *b.span(),
+                            ZeroSpan::from_range(
+                                modifier.range(),
+                                file.path))),
+                        unresolved: Box::new(b),
+                    }),
+                TokenKind::Vect => b = UnresolvedType::Vector(
+                    UnresolvedVectorType {
+                        base: TypeBase::from_span(ZeroSpan::combine(
+                            *b.span(),
+                            ZeroSpan::from_range(modifier.range(),
+                                                 file.path))),
+                        unresolved: Box::new(b),
+                    }),
+                _ => internal_error!(
+                    "Unexpected token in cdecl modifier list: {:?}",
+                    modifier.read_leaf(file.file).unwrap()),
+            }
+        }
+        if let Some((_, simple, _)) = &inner.inner {
+            b = modify_with_inner(b, simple, report, file);
+        }
+        b
+    }
+
+    Some(modify_with_inner(base, &content.simple, report, file))
+}
+
+// TODO: Expand unit tests
+#[cfg(test)]
+mod test {
+    use super::*;
+    use crate::analysis::parsing::misc::{CDeclContent, CDecl};
+    use crate::analysis::structure::expressions::IntegerLiteral;
+    use crate::analysis::structure::test::*;
+
+    // NOTE/TODO: For now we are just testing the cdecl re-structuring
+    // since it's the most complicated/confusing
+    // TODO: Add tests for errors reported in structural conversion
+    #[test]
+    fn cdecl_fun() {
+        let Some(((name, ty), ast_errors)) = parse_to_structure::<CDeclContent, CDecl, _, _>(
+            "float foo();",
+            deconstruct_cdecl,
+        ) else {
+            panic!("Structural test failed to parse");
+        };
+        assert!(ast_errors.is_empty(), "AST errors: {:?}", ast_errors);
+        assert_eq!(name.as_ref().map(|n|n.val.as_str()), Some("foo"));
+        let (return_type, argument_types) =
+            assert_match_destruct!(
+                &ty,
+                UnresolvedType::Function(UnresolvedFunctionType {
+                    return_type,
+                    argument_types,
+                    varargs: false,
+                    ..
+                }),
+                return_type, argument_types);
+        assert!(argument_types.is_empty());
+        assert_match_destruct!(
+            return_type.as_ref(),
+            UnresolvedType::Float(FloatType(_)));
+    }
+
+    #[test]
+    fn cdecl_struct() {
+        let Some(((name, ty), ast_errors)) = parse_to_structure::<CDeclContent, CDecl, _, _>(
+            "struct {
+                float a;
+                int b;
+             } struct_value;",
+            deconstruct_cdecl,
+        ) else {
+            panic!("Structural test failed to parse");
+        };
+        assert!(ast_errors.is_empty(), "AST errors: {:?}", ast_errors);
+        assert_eq!(name.as_ref().map(|n|n.val.as_str()), Some("struct_value"));
+        let member_types =
+            assert_match_destruct!(
+                &ty,
+                UnresolvedType::Struct(UnresolvedStructType {
+                    members,
+                    ..
+                }),
+                members);
+        // Fairly sure lexical order is guaranteed
+        let ((floatname, floatty), (intname, intty)) =
+            assert_match_destruct!(
+                &member_types[..],
+                [
+                    floatfield,
+                    intfield,
+                ],
+                floatfield, intfield);
+        assert_eq!(floatname.as_ref().map(|n|n.val.as_str()), Some("a"));
+        assert_match_destruct!(
+            floatty,
+            UnresolvedType::Float(FloatType(_)));
+        assert_eq!(intname.as_ref().map(|n|n.val.as_str()), Some("b"));
+        let int_name = assert_match_destruct!(
+            intty,
+            UnresolvedType::Named(NamedType { name, .. }),
+            name);
+        assert_eq!(int_name.val.as_str(), "int");
+    }
+
+    #[test]
+    fn cdecl_const() {
+        let Some(((name, ty), ast_errors)) = parse_to_structure::<CDeclContent, CDecl, _, _>(
+            "const float foo;",
+            deconstruct_cdecl,
+        ) else {
+            panic!("Structural test failed to parse");
+        };
+        assert!(ast_errors.is_empty(), "AST errors: {:?}", ast_errors);
+        assert_eq!(name.as_ref().map(|n|n.val.as_str()), Some("foo"));
+        let base = assert_match_destruct!(
+            &ty,
+            UnresolvedType::Float(FloatType(base)),
+            base);
+        assert!(base.is_const);
+    }
+
+    #[test]
+    fn cdecl_complicated() {
+        let Some(((name, ty), ast_errors)) = parse_to_structure::<CDeclContent, CDecl, _, _>(
+            "char (*(*foo())[5])();",
+            deconstruct_cdecl,
+        ) else {
+            panic!("Structural test failed to parse");
+        };
+        assert!(ast_errors.is_empty(), "AST errors: {:?}", ast_errors);
+        assert_eq!(name.as_ref().map(|n|n.val.as_str()), Some("foo"));
+        let (return_type, argument_types) =
+            assert_match_destruct!(
+                &ty,
+                UnresolvedType::Function(UnresolvedFunctionType {
+                    return_type,
+                    argument_types,
+                    varargs: false,
+                    ..
+                }),
+                return_type, argument_types);
+        let pointer = assert_match_destruct!(
+                return_type.as_ref(),
+                UnresolvedType::Pointer(UnresolvedPointerType {
+                    unresolved,
+                    ..
+                }),
+                unresolved);
+        assert_eq!(argument_types, &vec![]);
+        let (arr_ty, arr_size) = assert_match_destruct!(
+                pointer.as_ref(),
+                UnresolvedType::Array(UnresolvedArrayType {
+                    unresolved,
+                    size: Some(size_expr),
+                    ..
+                }),
+                unresolved,
+                size_expr);
+        let array_size_val = assert_match_destruct!(
+            arr_size.as_ref(),
+            ExpressionKind::IntegerLiteral(IntegerLiteral::Unsigned(val)),
+            val);
+        assert_eq!(array_size_val.val, 5);
+        let inner_fn_ty = assert_match_destruct!(
+                arr_ty.as_ref(),
+                UnresolvedType::Pointer(UnresolvedPointerType {
+                    unresolved,
+                    ..
+                }),
+                unresolved);
+        let (inner_return_type, inner_argument_types) =
+            assert_match_destruct!(
+                inner_fn_ty.as_ref(),
+                UnresolvedType::Function(UnresolvedFunctionType {
+                    return_type,
+                    argument_types,
+                    varargs: false,
+                    ..
+                }),
+                return_type, argument_types);
+        assert_eq!(inner_argument_types, &vec![]);
+        let inner_name = assert_match_destruct!(
+            inner_return_type.as_ref(),
+            UnresolvedType::Named(NamedType { name, .. }),
+            name);
+        assert_eq!(inner_name.val.as_str(), "char");
+    }
 }
diff --git a/src/analysis/symbols.rs b/src/analysis/symbols.rs
index 3ca08a4..de76f60 100644
--- a/src/analysis/symbols.rs
+++ b/src/analysis/symbols.rs
@@ -3,17 +3,18 @@
 use std::sync::Arc;
 
 use std::collections::HashSet;
-use std::sync::Mutex;
+use std::sync::{Mutex, Weak};
 
-use crate::analysis::{Named, LocationSpan};
+use crate::analysis::{LocationSpan, Named, templating};
 
 use crate::analysis::parsing::tree::ZeroSpan;
 use crate::analysis::structure::objects::{CompObjectKind};
 
 use crate::analysis::structure::expressions::DMLString;
-use crate::analysis::templating::objects::{DMLObject, DMLNamedMember, StructureKey};
 use crate::analysis::templating::methods::{DMLMethodRef};
-use crate::analysis::templating::types::DMLResolvedType;
+use crate::analysis::templating::objects::{DMLObject, DMLNamedMember,
+                                           StructureKey};
+use crate::analysis::templating::types::DMLType;
 use crate::analysis::templating::traits::DMLTemplate;
 
 #[derive(PartialEq, Eq, Debug, Clone, Copy, Hash, PartialOrd, Ord)]
@@ -116,10 +117,10 @@ pub enum SymbolSource {
     // TODO: same principle for shared methods? likely not, there is
     // no object for the topmost method
     Method(StructureKey, Arc<DMLMethodRef>),
-    MethodArg(Arc<DMLMethodRef>, DMLString),
-    MethodLocal(Arc<DMLMethodRef>, DMLString),
+    MethodArg(Arc<DMLMethodRef>, DMLString, DMLType),
+    MethodLocal(Arc<DMLMethodRef>, DMLString, DMLType),
     // TODO: RC this if it's expensive
-    Type(DMLResolvedType),
+    Type(DMLType),
     Template(Arc<DMLTemplate>),
 }
 
@@ -133,12 +134,12 @@ impl std::fmt::Debug for SymbolSource {
                 f.debug_struct("SymbolSource::Method")
                 .field("name", &meth.concrete_decl.decl.name.val)
                 .finish_non_exhaustive(),
-            SymbolSource::MethodArg(meth, name) => 
+            SymbolSource::MethodArg(meth, name, _) => 
                 f.debug_struct("SymbolSource::MethodArg")
                 .field("argument_name", &name.val)
                 .field("method_name", &meth.concrete_decl.decl.name.val)
                 .finish_non_exhaustive(),
-            SymbolSource::MethodLocal(meth, name) => 
+            SymbolSource::MethodLocal(meth, name, _) =>
                 f.debug_struct("SymbolSource::MethodLocal")
                 .field("name", &name.val)
                 .field("method_name", &meth.concrete_decl.decl.name.val)
@@ -170,11 +171,11 @@ impl SymbolSource {
 
     pub fn as_metharg(&self) -> Option<(&Arc<DMLMethodRef>, &DMLString)> {
         match self {
-            Self::MethodArg(arg, name) => Some((arg, name)),
+            Self::MethodArg(arg, name, _) => Some((arg, name)),
             _ => None
         }
     }
-    pub fn as_type(&self) -> Option<&DMLResolvedType> {
+    pub fn as_type(&self) -> Option<&DMLType> {
         match self {
             Self::Type(typ) => Some(typ),
             _ => None
@@ -200,12 +201,22 @@ impl SymbolSource {
         match self {
             SymbolSource::DMLObject(obj) => obj.as_shallow().map(|o| o.identity()),
             SymbolSource::Method(_, methref) => Some(methref.identity()),
-            SymbolSource::MethodArg(_, name) => Some(&name.val),
-            SymbolSource::MethodLocal(_, name) => Some(&name.val),
+            SymbolSource::MethodArg(_, name, _) => Some(&name.val),
+            SymbolSource::MethodLocal(_, name, _) => Some(&name.val),
             SymbolSource::Type(_) => None,
             SymbolSource::Template(templ) => Some(&templ.name),
         }
     }
+
+    pub fn resolved_type(&self) -> Option<&DMLType> {
+        match self {
+            SymbolSource::Type(ty) => Some(ty),
+            SymbolSource::DMLObject(obj) => obj.resolved_type(),
+            SymbolSource::MethodArg(_methref, _name, ty) => Some(ty),
+            SymbolSource::MethodLocal(_methref, _name, ty) => Some(ty),
+            _ => None,
+        }
+    }
 }
 
 // Intentionally omitted implementation of clone, should not be done
@@ -233,8 +244,9 @@ pub struct Symbol {
     // some param or method set in them
     pub implementations: HashSet<ZeroSpan>,
     pub source: SymbolSource,
-    // TODO: RC or box this if it's expensive
-    pub typed: Option<DMLResolvedType>,
+    // NOTE: This is the actual final type of this declaration, if any. Uses 'weak' to store an Rc into
+    // type storage.
+    pub typed: Option<Weak<templating::types::DMLType>>,
 }
 
 // We do this often enough to warrant a reusable pattern,
diff --git a/src/analysis/templating/methods.rs b/src/analysis/templating/methods.rs
index bf57a19..b98f071 100644
--- a/src/analysis/templating/methods.rs
+++ b/src/analysis/templating/methods.rs
@@ -7,17 +7,19 @@ use crate::analysis::parsing::tree::ZeroSpan;
 use crate::analysis::symbols::{DMLSymbolKind, MakeSymbolContainer,
                                StructureSymbol, SymbolContainer};
 use crate::analysis::structure::expressions::DMLString;
-use crate::analysis::structure::types::DMLType;
+use crate::analysis::structure::types::UnresolvedType;
 use crate::analysis::structure::objects::{MaybeAbstract, MethodArgument,
                                           MethodModifier, Method};
 use crate::analysis::structure::statements::{Statement, StatementKind};
 use crate::analysis::{DeclarationSpan, DMLNamed, DMLError};
 use crate::analysis::templating::Declaration;
 use crate::analysis::templating::objects::DMLNamedMember;
-use crate::analysis::templating::types::{eval_type_simple, DMLResolvedType};
+use crate::analysis::templating::types::{dmltype_equivalent,
+                                         eval_type_simple, DMLType,
+                                         GlobalTypeStorage};
 use crate::analysis::templating::traits::{DMLTrait};
 
-#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd)]
 pub enum DMLMethodArg {
     Typed(Declaration),
     Inline(DMLString),
@@ -42,13 +44,13 @@ impl DMLMethodArg {
     pub fn is_inline(&self) -> bool {
         matches!(self, DMLMethodArg::Inline(_))
     }
-    pub fn equivalent(&self, other: &DMLMethodArg) -> bool {
+    pub fn type_equivalent(&self, other: &DMLMethodArg) -> bool {
         match (self, other) {
             (DMLMethodArg::Inline(_), DMLMethodArg::Inline(_)) =>
                 true,
             (DMLMethodArg::Typed(decl1), DMLMethodArg::Typed(decl2)) =>
-                decl1.type_ref.equivalent(&decl2.type_ref),
-            _ => false
+                dmltype_equivalent(&decl1.type_ref, &decl2.type_ref),
+            _ => false,
         }
     }
     pub fn span(&self) -> &ZeroSpan {
@@ -57,34 +59,25 @@ impl DMLMethodArg {
             DMLMethodArg::Typed(decl) => &decl.name.span,
         }
     }
+    pub fn resolved_type(&self) -> DMLType {
+        match self {
+            DMLMethodArg::Inline(_) => None,
+            DMLMethodArg::Typed(decl) => decl.type_ref.clone(),
+        }
+    }
 }
 
-pub fn eval_method_args(args: &[MethodArgument], report: &mut Vec<DMLError>)
+pub fn eval_method_args(args: &[MethodArgument],
+                        types: &mut GlobalTypeStorage,
+                        report: &mut Vec<DMLError>)
                     -> Vec<DMLMethodArg> {
     args.iter().map(|arg|
                     match arg {
                         MethodArgument::Typed(name, typed) => {
-                            let (structs, type_ref) = eval_type_simple(
-                                typed, (), ());
-                            for s in &structs {
-                                report.push(
-                                    DMLError {
-                                        span: *s.span(),
-                                        description:
-                                            "Cannot use anonymous".to_string() +
-                                            " struct type in argument type",
-                                        related: vec![],
-                                        severity: Some(DiagnosticSeverity::ERROR),
-                                    });
-                            }
+                            let type_ref = eval_type_simple(typed, types, report);
                             DMLMethodArg::Typed(Declaration {
-                                type_ref: if structs.is_empty() {
-                                    type_ref.into()
-                                } else {
-                                    DMLResolvedType::Dummy(
-                                        *type_ref.span())
-                                },
-                                name: name.clone()
+                                type_ref,
+                                name: name.clone(),
                             })
                         },
                         MethodArgument::Inline(name) =>
@@ -92,29 +85,20 @@ pub fn eval_method_args(args: &[MethodArgument], report: &mut Vec<DMLError>)
                     }).collect()
 }
 
-pub fn eval_method_returns(returns: &[DMLType], report: &mut Vec<DMLError>)
-                       -> Vec<DMLResolvedType> {
+// NOTE: Returning pairs of spans and types for return, so we can point to
+// the location of the return spans when mismatches occur
+pub fn eval_method_returns(returns: &[UnresolvedType],
+                           types: &mut GlobalTypeStorage,
+                           report: &mut Vec<DMLError>)
+                           -> Vec<(ZeroSpan, DMLType)> {
     returns.iter().map(|ret| {
-        let (structs, type_ref) = eval_type_simple(ret, (), ());
-        for s in &structs {
-            report.push(
-                DMLError {
-                    span: *s.span(),
-                    description:
-                    "Cannot use anonymous struct type in return type".into(),
-                    related: vec![],
-                    severity: Some(DiagnosticSeverity::ERROR),
-                });
-        }
-        if structs.is_empty() {
-            type_ref.into()
-        } else {
-            DMLResolvedType::Dummy(*type_ref.span())
-        }
+        let decl_span = *ret.span();
+        let type_ref = eval_type_simple(ret, types, report);
+        (decl_span, type_ref)
     }).collect()
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd)]
 pub struct MethodDecl {
     pub name: DMLString,
     pub modifier: MethodModifier,
@@ -122,7 +106,7 @@ pub struct MethodDecl {
     pub default: bool,
     pub throws: bool,
     pub method_args: Vec<DMLMethodArg>,
-    pub return_types: Vec<DMLResolvedType>,
+    pub return_types: Vec<(ZeroSpan, DMLType)>,
     pub body: Statement,
     pub span: ZeroSpan,
 }
@@ -174,7 +158,7 @@ pub trait MethodDeclaration : DMLNamedMember + MaybeAbstract {
         true
     }
     fn args(&self) -> &Vec<DMLMethodArg>;
-    fn returns(&self) -> &Vec<DMLResolvedType>;
+    fn returns(&self) -> &Vec<(ZeroSpan, DMLType)>;
 
     // TODO: Let this take multiple overridden methods, as there are allowed cases
     // of that and we can provide better (fewer, more compact) reports, bundling
@@ -228,7 +212,7 @@ pub trait MethodDeclaration : DMLNamedMember + MaybeAbstract {
             });
         }
         for (arg1, arg2) in self.args().iter().zip(overridden.args()) {
-            if !arg1.equivalent(arg2) {
+            if !arg1.type_equivalent(arg2) {
                 report.push(DMLError {
                     span: *arg1.span(),
                     description: "Mismatching argument type in \
@@ -252,13 +236,15 @@ pub trait MethodDeclaration : DMLNamedMember + MaybeAbstract {
                 severity: Some(DiagnosticSeverity::ERROR),
             });
         }
-        for (type1, type2) in self.returns().iter().zip(overridden.returns()) {
-            if !type1.equivalent(type2) {
+        for ((span1, type1), (span2, type2)) in
+            self.returns().iter().zip(overridden.returns()) {
+            if type1.is_some() && type2.is_some()
+                && !dmltype_equivalent(type1, type2) {
                 report.push(DMLError {
-                    span: *type1.span(),
+                    span: *span1,
                     description: "Mismatching return type in \
                                   method override".to_string(),
-                    related: vec![(*type2.span(),
+                    related: vec![(*span2,
                                    "Corresponding return type declared here"
                                    .to_string())],
                     severity: Some(DiagnosticSeverity::ERROR),
@@ -285,13 +271,15 @@ impl MethodDeclaration for MethodDecl {
         &self.method_args
     }
 
-    fn returns(&self) -> &Vec<DMLResolvedType> {
+    fn returns(&self) -> &Vec<(ZeroSpan, DMLType)> {
         &self.return_types
     }
 }
 
 impl MethodDecl {
-    pub fn from_content(content: &Method, report: &mut Vec<DMLError>)
+    pub fn from_content(content: &Method,
+                        types: &mut GlobalTypeStorage,
+                        report: &mut Vec<DMLError>)
                         -> MethodDecl {
         MethodDecl {
             name: content.object.name.clone(),
@@ -300,8 +288,8 @@ impl MethodDecl {
             default: content.default,
             body: content.body.clone(),
             throws: content.throws,
-            method_args: eval_method_args(&content.arguments, report),
-            return_types: eval_method_returns(&content.returns, report),
+            method_args: eval_method_args(&content.arguments, types, report),
+            return_types: eval_method_returns(&content.returns, types, report),
             span: *content.span(),
         }
     }
@@ -372,7 +360,7 @@ impl MethodDeclaration for DMLMethodRef {
         self.concrete_decl.args()
     }
 
-    fn returns(&self) -> &Vec<DMLResolvedType> {
+    fn returns(&self) -> &Vec<(ZeroSpan, DMLType)> {
         self.concrete_decl.returns()
     }
 }
@@ -510,7 +498,7 @@ impl MethodDeclaration for DMLConcreteMethod {
         self.decl.args()
     }
 
-    fn returns(&self) -> &Vec<DMLResolvedType> {
+    fn returns(&self) -> &Vec<(ZeroSpan, DMLType)> {
         self.decl.returns()
     }
 }
diff --git a/src/analysis/templating/mod.rs b/src/analysis/templating/mod.rs
index d9a7e15..21eee3d 100644
--- a/src/analysis/templating/mod.rs
+++ b/src/analysis/templating/mod.rs
@@ -6,14 +6,14 @@ pub mod topology;
 pub mod types;
 pub mod traits;
 
-use crate::analysis::templating::types::DMLResolvedType;
+use crate::analysis::templating::types::DMLType;
 use crate::analysis::structure::expressions::DMLString;
 use crate::analysis::structure::objects::MaybeAbstract;
 use crate::analysis::DMLNamed;
 
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Hash)]
 pub struct Declaration {
-    pub type_ref: DMLResolvedType,
+    pub type_ref: DMLType,
     pub name: DMLString,
 }
 
diff --git a/src/analysis/templating/objects.rs b/src/analysis/templating/objects.rs
index 639d400..9acc2ad 100644
--- a/src/analysis/templating/objects.rs
+++ b/src/analysis/templating/objects.rs
@@ -27,7 +27,7 @@ use crate::analysis::structure::toplevel::{ExistCondition, ObjectDecl,
                                            StatementSpec, TopLevel};
 use crate::analysis::symbols::{DMLSymbolKind};
 use crate::analysis::templating::Declaration;
-use crate::analysis::templating::types::eval_type;
+use crate::analysis::templating::types::{eval_type, DMLType, GlobalTypeStorage};
 use crate::analysis::templating::methods::{DMLConcreteMethod, DMLMethodRef, DefaultCallReference, MethodDecl, MethodDeclaration};
 use crate::analysis::templating::topology::{InEachStruct, InferiorVariant,
                                             Rank, RankDesc, RankDescKind,
@@ -271,6 +271,7 @@ pub fn make_device<'t>(path: &CanonPath,
                        mut imp_map: HashMap<Import, CanonPath>,
                        container: &'t mut StructureContainer,
                        rankmaker: &mut RankMaker,
+                       types: &mut GlobalTypeStorage,
                        report: &mut Vec<DMLError>) -> &'t DMLCompositeObject {
     debug!("Creating a device for {:?}", path);
     // create the faux spec for the device toplevel, importing the device file
@@ -324,6 +325,7 @@ pub fn make_device<'t>(path: &CanonPath,
         &InEachSpec::default(),
         None,
         container,
+        types,
         report);
     let device_obj = container.get(obj_key).unwrap();
     trace!("Device components are: {:?}", device_obj.components);
@@ -384,6 +386,18 @@ impl DMLObject {
             _ => None,
         }
     }
+
+    pub fn resolved_type(&self) -> Option<&DMLType> {
+        match self {
+            DMLObject::CompObject(_) => None,
+            DMLObject::ShallowObject(obj) => match &obj.variant {
+                DMLShallowObjectVariant::Session(v)
+                | DMLShallowObjectVariant::Saved(v) =>
+                    Some(&v.declaration.type_ref),
+                _ => None,
+            },
+        }
+    }
     // NOTE: Used during symbol tracking to discard duplicate
     // symbols
     pub fn equivalent(&self, other: &DMLObject) -> bool {
@@ -1098,21 +1112,25 @@ enum VariableKind {
 }
 
 fn add_sessions(obj: &mut DMLCompositeObject,
-                sessions: SessionMapping) {
+                sessions: SessionMapping,
+                types: &mut GlobalTypeStorage,
+                errors: &mut Vec<DMLError>) {
     for (_, (used, mut decls)) in sessions {
         if used {
             let (_, (s, i)) = decls.swap_remove(0);
-            handle_variable(obj, s, i, VariableKind::Session)
+            handle_variable(obj, s, i, VariableKind::Session, types, errors)
         }
     }
 }
 
 fn add_saveds(obj: &mut DMLCompositeObject,
-              saveds: SavedMapping) {
+              saveds: SavedMapping,
+              types: &mut GlobalTypeStorage,
+              errors: &mut Vec<DMLError>) {
     for (_, (used, mut decls)) in saveds {
         if used {
             let (_, (s, i)) = decls.swap_remove(0);
-            handle_variable(obj, s, i, VariableKind::Saved)
+            handle_variable(obj, s, i, VariableKind::Saved, types, errors)
         }
     }
 }
@@ -1400,13 +1418,15 @@ fn create_object_instance(loc: Option<ZeroSpan>,
 fn handle_variable(obj: &mut DMLCompositeObject,
                    vardecl: VariableDecl,
                    init: Option<Initializer>,
-                   kind: VariableKind) {
-    let (_, typed) = eval_type(&vardecl.typed, (), (),
-                               false, None, false);
+                   kind: VariableKind,
+                   types: &mut GlobalTypeStorage,
+                   errors: &mut Vec<DMLError>) {
+    let type_ref = eval_type(&vardecl.typed, types,
+                               false, None, false, errors);
     let var = DMLVariable {
         declaration: Declaration {
             name: vardecl.object.name,
-            type_ref: typed.into(),
+            type_ref,
         },
         init,
     };
@@ -1447,6 +1467,7 @@ type CollectedSymbols = (HashMap<String, (ZeroSpan, Vec<ZeroSpan>)>,
                          MethodMapping, HookMapping, ObjectMapping);
 fn collect_symbols(parameters: &[DMLParameter],
                    obj_specs: &[Arc<ObjectSpec>],
+                   types: &mut GlobalTypeStorage,
                    report: &mut Vec<DMLError>) -> CollectedSymbols
 {
     // We will report all name collisions _after_ we have sorted and collected
@@ -1520,7 +1541,7 @@ fn collect_symbols(parameters: &[DMLParameter],
         }
         for method in &spec.methods {
             let to_insert = (spec.rank.clone(),
-                             MethodDecl::from_content(&method.obj, report));
+                             MethodDecl::from_content(&method.obj, types, report));
             let name = method.obj.object.name.val.clone();
             if let Some((_, e)) = methods.get_mut(&name) {
                 e.push(to_insert);
@@ -1679,6 +1700,7 @@ fn merge_composite_subobj<'c>(name: String,
                                           Arc<ObjectSpec>)>,
                               parent_key: Option<StructureKey>,
                               container: &'c mut StructureContainer,
+                              types: &mut GlobalTypeStorage,
                               report: &mut Vec<DMLError>) -> StructureKey {
     debug!("Merging a composite subobj for {}", name);
     let (auth_obj, auth_spec) = &specs.first().unwrap();
@@ -1779,6 +1801,7 @@ fn merge_composite_subobj<'c>(name: String,
                 parent_each_stmts,
                 parent_key,
                 container,
+                types,
                 report)
 }
 
@@ -1786,6 +1809,7 @@ fn merge_composite_subobjs<'c>(parent_each_stmts: &InEachSpec,
                                subobjs: ObjectMapping,
                                parent_key: Option<StructureKey>,
                                container: &'c mut StructureContainer,
+                               types: &mut GlobalTypeStorage,
                                report: &mut Vec<DMLError>)
                                -> Vec<StructureKey> {
     debug!("Merging composite subobjects");
@@ -1800,6 +1824,7 @@ fn merge_composite_subobjs<'c>(parent_each_stmts: &InEachSpec,
                                         .collect(),
                                         parent_key,
                                         container,
+                                        types,
                                         report))
         } else {
             None
@@ -1808,26 +1833,26 @@ fn merge_composite_subobjs<'c>(parent_each_stmts: &InEachSpec,
     // TODO: Check collisions of 'name' parameters
 }
 
-// Maps a method decl to the method definitions it directly overrides, and the method declarations it directly overrides
-type DeclMap<'t> = HashMap<&'t MethodDecl, HashSet<&'t MethodDecl>>;
+// Maps a method decl loc span to the loc spans of the method definitions and declarations it directly overrides
+type DeclMap<'t> = HashMap<&'t ZeroSpan, HashSet<&'t ZeroSpan>>;
 
 // return a tuple (default_map, order, declaration_map)
 // where 'default_map' maps method declarations to definitions they directly override
 // and 'order' is a order of methods, with lowest rank being last
 // and 'declaration_map' maps method declarations to the abstract method declarations they directly override
 fn sort_method_decls<'t>(decls: &[(&Rank, &'t MethodDecl)]) ->
-    (DeclMap<'t>, Vec<&'t MethodDecl>, DeclMap<'t>) {
+    (DeclMap<'t>, Vec<&'t ZeroSpan>, DeclMap<'t>) {
         debug!("Sorting method decls {:?}", decls);
-        let mut rank_to_method_def: HashMap<&Rank, Vec<&MethodDecl>>
+        let mut rank_to_method_def: HashMap<&Rank, Vec<&'t ZeroSpan>>
             = HashMap::default();
-        let mut rank_to_method_decl: HashMap<&Rank, Vec<&MethodDecl>>
+        let mut rank_to_method_decl: HashMap<&Rank, Vec<&'t ZeroSpan>>
             = HashMap::default();
 
         for (rank, decl) in decls {
             if decl.is_abstract() {
-                rank_to_method_decl.entry(rank).or_default().push(*decl);
+                rank_to_method_decl.entry(rank).or_default().push(&decl.span);
             } else {
-                rank_to_method_def.entry(rank).or_default().push(*decl);
+                rank_to_method_def.entry(rank).or_default().push(&decl.span);
             }
         }
         trace!("rank-to-method-def is: {:?}, rank-to-method-decl is: {:?}", rank_to_method_def, rank_to_method_decl);
@@ -1867,19 +1892,19 @@ fn sort_method_decls<'t>(decls: &[(&Rank, &'t MethodDecl)]) ->
         // Map method definitions to abstract decls they override, which none of their minimal ancestors override
         let mut method_map_decls: DeclMap<'t> = HashMap::default();
         for (rank, ancestors) in &decl_ancestry {
-            for def in rank_to_method_def.get(rank).unwrap() {
+            for def in rank_to_method_def.get(rank).unwrap().iter().copied() {
                 method_map_decls.entry(def).or_default();
                 for ancestor in ancestors {
                     if !minimal_ancestry.get(rank).unwrap().iter().any(
                         |ma|decl_ancestry.get(ma).unwrap().iter().any(|a|a == ancestor)) {
                         if let Some(decls) = rank_to_method_decl.get(ancestor) {
-                            method_map_decls.entry(def).or_default().extend(decls.iter());
+                            method_map_decls.entry(def).or_default().extend(decls.iter().copied());
                         }
                     }
                 }
                 // Decls at the same rank are also directly overridden, by definition
                 if let Some(decls) = rank_to_method_decl.get(rank) {
-                    method_map_decls.entry(def).or_default().extend(decls.iter());
+                    method_map_decls.entry(def).or_default().extend(decls.iter().copied());
                 }
                 trace!("Method {:?} at rank {:?} directly overrides decls {:?}",
                     def, rank, method_map_decls.get(def).unwrap());
@@ -1891,28 +1916,28 @@ fn sort_method_decls<'t>(decls: &[(&Rank, &'t MethodDecl)]) ->
         let mut method_map_defs: DeclMap<'t> = HashMap::default();
 
         for (r, defs) in &rank_to_method_def {
-            for def in defs {
+            for def in defs.iter().copied() {
                 trace!("Handling method {:?} at rank {:?}", def, r);
                 // Ensure the entry exists for later unwraps
                 let mdefs = method_map_defs.entry(def).or_default();
                 for subrank in &minimal_ancestry[r] {
                     let subdefs = rank_to_method_def.get(subrank).unwrap();
                     trace!("Set as overriding {:?}", subdefs);
-                    mdefs.extend(subdefs.iter());
+                    mdefs.extend(subdefs.iter().copied());
                 }
             }
         }
             
         trace!("Default map is {:?}", method_map_defs);
         trace!("Abstract override map is {:?}", method_map_decls);
-        let method_order = topsort(&method_map_defs).unwrap_sorted();
+        let method_order: Vec<&'t ZeroSpan> = topsort(&method_map_defs).unwrap_sorted();
         trace!("Method order is {:?}", method_order);
         (method_map_defs, method_order, method_map_decls)
 }
 
 fn add_methods(obj: &mut DMLCompositeObject,
                methods: MethodMapping,
-               decl_to_trait_map: &HashMap<MethodDecl, Arc<DMLTrait>>,
+               decl_to_trait_map: &HashMap<ZeroSpan, Arc<DMLTrait>>,
                report: &mut Vec<DMLError>) {
     debug!("Adding methods to {}", obj.identity());
 
@@ -1925,60 +1950,66 @@ fn add_methods(obj: &mut DMLCompositeObject,
                name, regular_decls);
         let all_decls: Vec<(&Rank, &MethodDecl)>
             = regular_decls.iter().map(|(a, b)|(a, b)).collect();
+        let decls_by_span: HashMap<ZeroSpan, &MethodDecl> = all_decls.iter()
+            .map(|(_, decl)|(decl.span, *decl)).collect();
 
-        let (default_map, method_order, decl_map) = sort_method_decls(&all_decls);
-        let mut decl_to_method: HashMap<MethodDecl, Arc<DMLMethodRef>>
+        let (default_map, method_order, decl_map) =
+            sort_method_decls(&all_decls);
+        let mut decl_to_method: HashMap<ZeroSpan, Arc<DMLMethodRef>>
             = HashMap::default();
         // Create abstract methodrefs for declarations first, order does not matter
-        for method in decl_map.values().flatten() {
-            if decl_to_method.contains_key(method) {
+        for span in decl_map.values().flatten().copied() {
+            if decl_to_method.contains_key(span) {
                 continue;
             }
+            let method = *decls_by_span.get(span).unwrap();
             let template_ref = decl_to_trait_map
-                .get(method)
+                .get(span)
                 .map(Arc::clone);
 
             let new_method = Arc::new(
                 DMLMethodRef {
                     template_ref,
                     concrete_decl: DMLConcreteMethod {
-                        decl: (*method).clone(),
+                        decl: method.clone(),
                         default_call: None,
                     },
                 }
             );
             trace!("Inserted dependent methoddecl {:?}", new_method);
-            decl_to_method.insert((*method).clone(), new_method);
+            decl_to_method.insert(*span, new_method);
         }
         trace!("Abstract decl methods are {:?}", decl_to_method);
-        for method in method_order.iter().rev() {
+        for span in method_order.iter().copied().rev() {
+            let method = *decls_by_span.get(span).unwrap();
             trace!("Handling overrides of {:?}", method);
             // Guaranteed by topsort
-            let defaults = default_map.get(method).unwrap();
+            let defaults = default_map.get(span).unwrap();
             let default = match defaults.len() {
                 1 => {
-                    let decl = defaults.iter().next().unwrap();
-                    Some(DefaultCallReference::Valid(Arc::clone(decl_to_method.get(decl).unwrap())))
+                    let decl_span = defaults.iter().copied().next().unwrap();
+                    Some(DefaultCallReference::Valid(Arc::clone(decl_to_method.get(decl_span).unwrap())))
                 },
-                0 => decl_map.get(method).and_then(|decls| {
+                0 => decl_map.get(span).and_then(|decls| {
                     match decls.len()  {
                         1 => Some(DefaultCallReference::Abstract(
-                            Arc::clone(decls.iter().next().and_then(|d|decl_to_method.get(d)).unwrap()))),
+                            Arc::clone(decls.iter().copied().next().and_then(|d|decl_to_method.get(d)).unwrap()))),
                         // The case of conflicting abstract declarations is handled elsewhere
                         _ => None,
                     }
                 }),
                 _ => Some(DefaultCallReference::Ambiguous(
-                    defaults.iter().map(|d| Arc::clone(decl_to_method.get(d).unwrap())).collect())),
+                    defaults.iter().copied().map(|d| Arc::clone(decl_to_method.get(d).unwrap())).collect())),
             };
             trace!("Default call would be {:?}", default);
-            for decl in defaults.iter().chain(decl_map.get(method).unwrap_or(&HashSet::default())) {
+            for decl_span in defaults.iter().chain(decl_map.get(span).unwrap_or(&HashSet::default())).copied() {
                 // TODO: I suspect we could improve this error message in cases
                 // where several similar incorrect overrides are made over one
                 // method
                 // We need to store it in a wider context and collect
                 // it after this to report at most one diagnostic per
                 // declaration
+                let decl = *decls_by_span.get(decl_span).unwrap();
 
                 if !decl.default && !decl.is_abstract() {
                     report.push(DMLError {
@@ -1991,28 +2022,28 @@ fn add_methods(obj: &mut DMLCompositeObject,
                     });
                 }
 
-                 method.check_override(*decl, report);
+                 method.check_override(decl, report);
             }
 
             let template_ref = decl_to_trait_map
-                .get(method)
+                .get(span)
                 .map(Arc::clone);
 
             let new_method = Arc::new(
                 DMLMethodRef {
                     template_ref,
                     concrete_decl: DMLConcreteMethod {
-                        decl: (*method).clone(),
+                        decl: method.clone(),
                         default_call: default,
                     },
                 }
             );
             trace!("Inserted dependent methoddecl {:?}", new_method);
-            decl_to_method.insert((*method).clone(), new_method);
+            decl_to_method.insert(*span, new_method);
         }
         trace!("Complete decl-to-method map is: {:?}", decl_to_method);
         // If there are no definitions, skip to next method (declarations are separately added above)
-        let Some(to_add) = method_order.first().map(|m|decl_to_method.get(m).unwrap()) else { continue; };
+        let Some(to_add) = method_order.first().map(|s|decl_to_method.get(*s).unwrap()) else { continue; };
         debug!("Added {:?}", to_add.identity());
         obj.add_shallow_component(DMLShallowObjectVariant::Method(
             Arc::clone(to_add)));
@@ -2264,6 +2295,7 @@ pub fn make_object(loc: ZeroSpan,
                    parent_each_stmts: &InEachSpec,
                    parent_key: Option<StructureKey>,
                    container: &mut StructureContainer,
+                   types: &mut GlobalTypeStorage,
                    report: &mut Vec<DMLError>) -> StructureKey {
     debug!("Making object {}", identity.val);
 
@@ -2293,7 +2325,7 @@ pub fn make_object(loc: ZeroSpan,
     let (symbols, constants,
          saveds, sessions,
          methods, hooks,
-         subobjs) = collect_symbols(&parameters, &obj_specs, report);
+         subobjs) = collect_symbols(&parameters, &obj_specs, types, report);
     trace!("All local symbols are: {:?}",
            symbols.keys().map(|k|k.as_str()).collect::<Vec<&str>>());
 
@@ -2304,7 +2336,7 @@ pub fn make_object(loc: ZeroSpan,
 
     let subobj_keys =
         merge_composite_subobjs(&each_stmts, subobjs,
-                                Some(new_obj_key), container, report);
+                                Some(new_obj_key), container, types, report);
 
     {
         let new_obj = container.get_mut(new_obj_key).unwrap();
@@ -2313,17 +2345,17 @@ pub fn make_object(loc: ZeroSpan,
         add_constants(new_obj, constants);
         add_parameters(new_obj, parameters);
         add_hooks(new_obj, hooks);
-        add_saveds(new_obj, saveds);
-        add_sessions(new_obj, sessions);
+        add_saveds(new_obj, saveds, types, report);
+        add_sessions(new_obj, sessions, types, report);
     }
     // We need to drop the new_obj reference here, so that we can
     // access multiple keys simultaneously from the storage
     add_subobjs(new_obj_key, subobj_keys, container);
     {
         let new_obj = container.get_mut(new_obj_key).unwrap();
-        let trait_method_map = new_obj.templates.values()
+        let trait_method_map: HashMap<ZeroSpan, Arc<DMLTrait>> = new_obj.templates.values()
             .flat_map(|t|t.traitspec.methods.values()
-                      .map(|m|(m.decl.clone(), Arc::clone(&t.traitspec)))
+                      .map(|m|(m.decl.span, Arc::clone(&t.traitspec)))
                       .collect::<Vec<_>>())
             .collect();
 
diff --git a/src/analysis/templating/topology.rs b/src/analysis/templating/topology.rs
index c3e9ad1..4ebf3bf 100644
--- a/src/analysis/templating/topology.rs
+++ b/src/analysis/templating/topology.rs
@@ -24,6 +24,7 @@ use crate::analysis::templating::objects::{create_objectspec};
 use crate::analysis::templating::traits::{TemplateTraitInfo,
                                           DMLTemplate,
                                           DMLTrait};
+use crate::analysis::templating::types::GlobalTypeStorage;
 use crate::file_management::CanonPath;
 
 lazy_static! {
@@ -132,7 +133,7 @@ impl RankDescKind {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Hash)]
 pub struct RankDesc {
     pub kind: RankDescKind,
     pub desc: String,
@@ -171,6 +172,7 @@ pub fn create_templates_traits<'t>(
     invalid_isimps: HashMap<InferiorVariant<'t>, Vec<&'t str>>,
     imp_map: &'t HashMap<Import, CanonPath>,
     rank_struct: HashMap<&'t str, InEachStruct<'t>>,
+    types: &mut GlobalTypeStorage,
     report: &mut Vec<DMLError>)
     -> TemplateTraitInfo {
     let mut templates = HashMap::default();
@@ -198,7 +200,7 @@ pub fn create_templates_traits<'t>(
         // also creating traits in any case, just with nothing
         // in them
         let traitspec = DMLTrait::process(templname, templ.get_def_loc(),
-                                          &spec, &traits, report);
+                                          &spec, &traits, types, report);
         traits.insert(templname.to_string(), Arc::clone(&traitspec));
         let template = DMLTemplate::make(
             templname,
@@ -565,10 +567,13 @@ pub fn rank_templates_aux<'t>(mut templates: HashMap<&'t str,
             in_eachs,
             unconditional_references,
         } = dependencies(template.get_spec(), imp_map);
+
         let referenced: HashSet<&'t str>
-            = inferior.keys().filter(|s|!invalid_isimps.values().flatten().
-                                     any(|s2|&s2 == s))
-            .cloned().collect();
+            = inferior.iter().filter(
+                |(name, kind)| invalid_isimps.get(kind)
+                    .is_none_or(|invalid_names| !invalid_names.contains(name)))
+            .map(|(name, _)| *name)
+            .collect();
         trace!("Template {:?} requires {:?}", template.get_name(), referenced);
         required_templates.insert(template.get_name(), referenced.clone());
         let all_missing: HashSet<&'t str> = referenced.difference(
@@ -771,7 +776,7 @@ pub fn rank_templates_aux<'t>(mut templates: HashMap<&'t str,
                                 removed_one = true;
                                 invalid_isimps.entry(InferiorVariant::Is(inst))
                                     .and_modify(|v|v.push(second))
-                                    .or_default();
+                                    .or_insert_with(||vec![second]);
                             }
                     },
                     StatementSpecStatement::Import(imp) => {
@@ -784,7 +789,7 @@ pub fn rank_templates_aux<'t>(mut templates: HashMap<&'t str,
                             removed_one = true;
                             invalid_isimps.entry(InferiorVariant::Import(imp))
                                 .and_modify(|v|v.push(second))
-                                .or_default();
+                                .or_insert_with(||vec![second]);
                         }
                     }
                     _ => (),
@@ -812,14 +817,16 @@ fn traverse<'t, T>(graph: &HashMap<&'t T, HashSet<&'t T>>,
                    visited: &mut HashSet<&'t T>,
                    result: &mut Vec<&'t T>) -> Option<Vec<&'t T>>
 where
-    T : std::hash::Hash + std::cmp::Eq + ?Sized
+    T : std::hash::Hash + std::cmp::Eq + std::cmp::Ord + ?Sized
 {
     if path.contains(&currnode) {
         let (_, rest) = path.split_at(path.iter().position(
             |prevnode|*prevnode == currnode).unwrap());
         Some(rest.into())
     } else {
-        for nextnode in &graph[currnode] {
+        let mut nextnodes: Vec<&'t T> = graph[currnode].iter().copied().collect();
+        nextnodes.sort();
+        for nextnode in nextnodes {
             if !visited.contains(nextnode) {
                 let mut newpath = path.clone();
                 newpath.push(currnode);
@@ -853,11 +860,13 @@ impl <T> SortResult<T> {
 pub fn bottomsort<'t, T>(graph: &HashMap<&'t T, HashSet<&'t T>>)
                       -> SortResult<&'t T>
 where
-    T : std::hash::Hash + std::cmp::Eq + ?Sized
+    T : std::hash::Hash + std::cmp::Eq + std::cmp::Ord + ?Sized
 {
     let mut visited = HashSet::new();
     let mut result = vec![];
-    for startnode in graph.keys() {
+    let mut startnodes: Vec<&'t T> = graph.keys().copied().collect();
+    startnodes.sort();
+    for startnode in startnodes {
         if !visited.contains(startnode) {
             if let Some(cycle) = traverse(graph, startnode, vec![],
                                           &mut visited, &mut result) {
@@ -871,7 +880,7 @@ where
 pub fn topsort<'t, T>(graph: &HashMap<&'t T, HashSet<&'t T>>)
                       -> SortResult<&'t T>
 where
-    T : std::hash::Hash + std::cmp::Eq + ?Sized
+    T : std::hash::Hash + std::cmp::Eq + std::cmp::Ord + ?Sized
 {
     match bottomsort(graph) {
         SortResult::Sorted(mut result) => {
diff --git a/src/analysis/templating/traits.rs b/src/analysis/templating/traits.rs
index 11e3774..1935694 100644
--- a/src/analysis/templating/traits.rs
+++ b/src/analysis/templating/traits.rs
@@ -18,7 +18,7 @@ use crate::analysis::templating::objects::{CoarseObjectKind,
                                            DMLCoarseObjectKind,
                                            ObjectSpec, Spec};
 use crate::analysis::templating::Declaration;
-use crate::analysis::templating::types::eval_type_simple;
+use crate::analysis::templating::types::{eval_type_simple, GlobalTypeStorage};
 use crate::analysis::templating::topology::Rank;
 
 use crate::analysis::DeclarationSpan;
@@ -258,6 +258,7 @@ impl DMLTrait {
                    maybeloc: Option<&ZeroSpan>,
                    spec: &Arc<ObjectSpec>,
                    traits: &HashMap<String, Arc<DMLTrait>>,
+                   types: &mut GlobalTypeStorage,
                    report: &mut Vec<DMLError>)
                    -> Arc<DMLTrait> {
         debug!("Processing trait for {}", name);
@@ -345,62 +346,61 @@ impl DMLTrait {
 
         // Flatten sessions and saveds into non-colliding data declarations
         // with resolved types
-        let sessions: HashMap<String, Declaration> =
-            spec.sessions.iter().filter_map(discard_conditional)
-            .flat_map(|sess|sess.vars)
-            .map(|decl|Declaration {
-                name: decl.object.name.clone(),
-                type_ref: {
-                    // TODO: How to actually evaluate this?
-                    // Needs global scope
-                    let (_, typ) = eval_type_simple(
-                        &decl.typed, (), ());
-                    typ.into()
-                }
-            }).filter(|d|maybe_report_collision(
-                &mut used_names,
-                d.name.val.clone(),
-                d.name.span,
-                report)).map(|d|(d.name.val.clone(), d)).collect();
+        let mut sessions: HashMap<String, Declaration> = HashMap::default();
+        for decl in spec.sessions.iter().filter_map(discard_conditional)
+            .flat_map(|sess|sess.vars) {
+                let typ = eval_type_simple(&decl.typed, types, report);
+                let d = Declaration {
+                    name: decl.object.name.clone(),
+                    type_ref: typ,
+                };
+                if maybe_report_collision(
+                    &mut used_names,
+                    d.name.val.clone(),
+                    d.name.span,
+                    report) {
+                        sessions.insert(d.name.val.clone(), d);
+                    }
+            }
         trace!("sessions are: {:?}", sessions);
 
-        let saveds: HashMap<String, Declaration> =
-            spec.saveds.iter().filter_map(discard_conditional)
-            .flat_map(|sav|sav.vars)
-            .map(|decl|Declaration {
-                name: decl.object.name.clone(),
-                type_ref: {
-                    // TODO: How to actually evaluate this?
-                    // Needs global scope
-                    let (_, typ) = eval_type_simple(
-                        &decl.typed, (), ());
-                    typ.into()
-                }
-            }).filter(|d|maybe_report_collision(
-                &mut used_names,
-                d.name.val.clone(),
-                d.name.span,
-                report)).map(|d|(d.name.val.clone(), d)).collect();
+        let mut saveds: HashMap<String, Declaration> = HashMap::default();
+        for decl in spec.saveds.iter().filter_map(discard_conditional)
+            .flat_map(|sav|sav.vars) {
+                let typ = eval_type_simple(&decl.typed, types, report);
+                let d = Declaration {
+                    name: decl.object.name.clone(),
+                    type_ref: typ,
+                };
+                if maybe_report_collision(
+                    &mut used_names,
+                    d.name.val.clone(),
+                    d.name.span,
+                    report) {
+                        saveds.insert(d.name.val.clone(), d);
+                    }
+            }
         trace!("saveds are: {:?}", saveds);
 
         // Map typed parameters into non-colliding declarations
-        let params: HashMap<String, Declaration> = spec.params.iter()
+        let mut params: HashMap<String, Declaration> = HashMap::default();
+        for param in spec.params.iter()
             .filter_map(discard_conditional)
-            .filter(|param|param.typed.is_some())
-            .map(|param|Declaration {
-                name: param.object.name.clone(),
-                type_ref: {
-                    // TODO: How to actually evaluate this?
-                    // Needs global scope
-                    let (_, typ) = eval_type_simple(
-                        &param.typed.unwrap(), (), ());
-                    typ.into()
-                }
-            }).filter(|d|maybe_report_collision(
-                &mut used_names,
-                d.name.val.clone(),
-                d.name.span,
-                report)).map(|d|(d.name.val.clone(), d)).collect();
+            .filter(|param|param.typed.is_some()) {
+                let typ = eval_type_simple(
+                    &param.typed.clone().unwrap(), types, report);
+                let d = Declaration {
+                    name: param.object.name.clone(),
+                    type_ref: typ,
+                };
+                if maybe_report_collision(
+                    &mut used_names,
+                    d.name.val.clone(),
+                    d.name.span,
+                    report) {
+                        params.insert(d.name.val.clone(), d);
+                    }
+            }
         trace!("params are: {:?}", params);
 
         // Map methods into non-colliding method declarations
@@ -408,7 +408,7 @@ impl DMLTrait {
             .filter_map(discard_conditional)
             .filter(|method|method.is_abstract())
             .filter_map(|m| {
-                let new_m = MethodDecl::from_content(&m, report);
+                let new_m = MethodDecl::from_content(&m, types, report);
                 if maybe_report_collision(
                     &mut used_names,
                     new_m.identity().to_string(),
@@ -424,7 +424,7 @@ impl DMLTrait {
         for method in spec.methods.iter()
             .filter_map(discard_conditional)
             .filter(|method|!method.is_abstract()) {
-            let new_m = MethodDecl::from_content(&method, report);
+            let new_m = MethodDecl::from_content(&method, types, report);
             // special case, methods are allowed to conflict 
             // with abstract methods
             // NOTE: Right now this means we'd report the collision
diff --git a/src/analysis/templating/types.rs b/src/analysis/templating/types.rs
index bead0f9..1904a18 100644
--- a/src/analysis/templating/types.rs
+++ b/src/analysis/templating/types.rs
@@ -1,92 +1,595 @@
 //  © 2024 Intel Corporation
 //  SPDX-License-Identifier: Apache-2.0 and MIT
+
+// This file describes RESOLVED DML types
+
+use crate::analysis::structure::expressions::DMLString;
+// These are the types which we can directly re-use from the structural part,
+// as they are the same resolved and unresolved
+use crate::analysis::structure::types::{
+    BitfieldsType, BoolType, DeviceType, DoubleType, EndianIntType, Endianness, FloatType, IntType, NamedType, ResolveableType, TypeBase, UnresolvedType, VoidType};
+use crate::analysis::structure::objects::Typedef;
 use crate::analysis::parsing::tree::ZeroSpan;
+use crate::analysis::{DMLError, DeclarationSpan, LocationSpan, IdentitySpan, DMLNamed};
 
+use lsp_types::DiagnosticSeverity;
 
-use crate::analysis::structure::types::DMLType;
+use std::sync::Arc;
+use std::collections::{HashMap, HashSet};
+use std::path::PathBuf;
 
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub struct DMLBaseType {
-    no_info: ZeroSpan,
+#[derive(Debug, Clone, PartialEq, Eq)]
+struct TypedefEntry {
+    unresolved: Arc<UnresolvedType>,
+    decl_name: DMLString,
+    is_extern: bool,
 }
 
-impl DMLBaseType {
-    pub fn span(&self) -> &ZeroSpan {
-        &self.no_info
+#[derive(Debug, Clone, PartialEq, Eq)]
+struct TemplateEntry {
+    decl_name: DMLString,
+}
+
+/// Global storage of typedef information and a cache of resolved types, used
+/// when resolving `UnresolvedType`s during templating.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct GlobalTypeStorage {
+    /// Map from typedef name to its declaration info.
+    type_decls: HashMap<String, TypedefEntry>,
+    /// Map from template name to its declaration info
+    template_decls: HashMap<String, TemplateEntry>,
+    /// Cache of fully resolved underlying types
+    resolved_cache: HashMap<String, DMLType>,
+    /// Built-in named types that are not parser-level primitives (size_t and the like)
+    builtin_named_types: HashMap<String, DMLType>,
+}
+
+// Used as recursion guard while resolving types
+#[derive(Debug, Default)]
+pub struct ResolvingState {
+    in_progress: HashSet<String>,
+    // Path of resolution, used for diagnostic info
+    path: Vec<(String, ZeroSpan)>,
+}
+
+impl GlobalTypeStorage {
+    /// `path` is only used to construct the (location-less) spans of the
+    /// built-in named types, and is typically the device's root file.
+    pub fn new<F: Into<PathBuf>>(path: F) -> Self {
+        Self {
+            type_decls: HashMap::new(),
+            template_decls: HashMap::new(),
+            resolved_cache: HashMap::new(),
+            builtin_named_types: make_builtin_named_types(path.into()),
+        }
+    }
+
+    /// Registers a typedef, returning the existing declaration span if one
+    /// with this name was already registered
+    pub fn add_typedef(&mut self, typedef: &Typedef) -> Option<ZeroSpan> {
+        let name = typedef.name();
+        match self.type_decls.entry(name.val.clone()) {
+            std::collections::hash_map::Entry::Occupied(entry) =>
+                Some(entry.get().decl_name.span),
+            std::collections::hash_map::Entry::Vacant(entry) => {
+                entry.insert(TypedefEntry {
+                    unresolved: Arc::new(typedef.typed.clone()),
+                    decl_name: name.clone(),
+                    is_extern: typedef.is_extern,
+                });
+                None
+            }
+        }
+    }
+
+    /// Register a template as a type
+    pub fn add_template(&mut self, decl_name: DMLString) {
+        self.template_decls.insert(decl_name.val.clone(),
+                                   TemplateEntry { decl_name });
     }
+
+    fn template_decl_name(&self, name: &str) -> Option<DMLString> {
+        self.template_decls.get(name).map(|entry| entry.decl_name.clone())
+    }
+
+    /// resolves a named type to a typedef
+    pub fn resolve_named(&mut self, named: &NamedType,
+                         resolving: &mut ResolvingState,
+                         is_extern: bool, via_indirection: bool,
+                         errors: &mut Vec<DMLError>) -> DMLType {
+        let name_str = named.name.val.clone();
+
+        let Some(entry) = self.type_decls.get(&name_str).cloned() else {
+            // Fall back to seeing if we have a template of this name to use
+            // as a type
+            if let Some(decl_name) = self.template_decl_name(&name_str) {
+                return Some(Arc::new(DMLConcreteType::Trait(DMLTraitType {
+                    base: named.base.clone(),
+                    decl_name,
+                })));
+            }
+            if let Some(ty) = self.builtin_named_types.get(&name_str) {
+                return ty.clone();
+            }
+
+            errors.push(DMLError {
+                span: named.name.span,
+                description: format!("Unknown type '{}'", &name_str),
+                // TODO: It is relatively easy to find suggestions for closely-named types here,
+                // however I want the suggestion-feature-search to be its own module so for now this is
+                // unimplemented
+                related: vec![],
+                severity: Some(DiagnosticSeverity::ERROR),
+            });
+            return None;
+        };
+
+        if resolving.in_progress.contains(&name_str) {
+            // Skip reporting cycles directly under externs or
+            // pointers
+            if !is_extern && !via_indirection {
+                let cycle_start = resolving.path.iter()
+                    .position(|(n, _)| n == &name_str)
+                    .unwrap_or(0);
+                let mut related: Vec<(ZeroSpan, String)> =
+                    resolving.path[cycle_start + 1..].iter()
+                    .map(|(n, span)| (*span,
+                                      format!("through '{}' here", n)))
+                    .collect();
+                related.push((named.name.span,
+                              "Cyclic reference occurs here".to_string()));
+                errors.push(DMLError {
+                    span: entry.decl_name.span,
+                    description: format!(
+                        "Typedef '{}' is cyclically defined", &name_str),
+                    related,
+                    severity: Some(DiagnosticSeverity::ERROR),
+                });
+            }
+            // Blank out the alias type
+            return Some(Arc::new(DMLConcreteType::Typedef(DMLTypedefType {
+                base: named.base.clone(),
+                decl_name: entry.decl_name.clone(),
+                underlying: None,
+            })));
+        }
+
+        let underlying = self.resolve_entry_underlying(
+            &name_str, &entry, resolving, errors);
+
+        Some(Arc::new(DMLConcreteType::Typedef(DMLTypedefType {
+            base: named.base.clone(),
+            decl_name: entry.decl_name.clone(),
+            underlying,
+        })))
+    }
+
+    fn resolve_entry_underlying(&mut self, name: &str, entry: &TypedefEntry,
+                               resolving: &mut ResolvingState,
+                               errors: &mut Vec<DMLError>) -> DMLType {
+        if let Some(cached) = self.resolved_cache.get(name) {
+            return cached.clone();
+        }
+        resolving.in_progress.insert(name.to_string());
+        resolving.path.push((name.to_string(), entry.decl_name.span));
+        let resolved = entry.unresolved.resolve(self, resolving, entry.is_extern, false, errors);
+        resolving.path.pop();
+        resolving.in_progress.remove(name);
+        self.resolved_cache.insert(name.to_string(), resolved.clone());
+        resolved
+    }
+
+    pub fn get_underlying(&self, name: &str) -> Option<&DMLType> {
+        self.resolved_cache.get(name)
+    }
+
+    pub fn typedef_decl_span(&self, name: &str) -> Option<ZeroSpan> {
+        self.type_decls.get(name).map(|entry|entry.decl_name.span)
+    }
+
+    pub fn typedef_decl_spans(&self) -> impl Iterator<Item = (&str, ZeroSpan)> + '_ {
+        self.type_decls.iter().map(|(name, entry)|(name.as_str(), entry.decl_name.span))
+    }
+
+    // re-constructs a typedef wrapper around a name
+    pub fn typedef_as_type(&self, name: &str) -> DMLType {
+        let entry = self.type_decls.get(name)?;
+        let underlying = self.resolved_cache.get(name).cloned().unwrap_or(None);
+        Some(Arc::new(DMLConcreteType::Typedef(DMLTypedefType {
+            base: TypeBase {
+                is_const: false,
+                decl_span: entry.decl_name.span,
+            },
+            decl_name: entry.decl_name.clone(),
+            underlying,
+        })))
+    }
+
+    // Resolves all typedefs
+    pub fn resolve_all(&mut self, errors: &mut Vec<DMLError>) {
+        let mut names: Vec<String> = self.type_decls.keys().cloned().collect();
+        names.sort();
+        for name in names {
+            if self.resolved_cache.contains_key(&name) {
+                continue;
+            }
+            let entry = self.type_decls[&name].clone();
+            let mut resolving = ResolvingState::default();
+            self.resolve_entry_underlying(&name, &entry, &mut resolving, errors);
+        }
+    }
+
+    pub fn resolved_types(&self) -> impl Iterator<Item = &DMLType> {
+        self.resolved_cache.values()
+    }
+}
+
+// The location of built-in types is faked as an invalid span of the
+// device file
+fn make_builtin_named_types(path: PathBuf) -> HashMap<String, DMLType> {
+    let base = TypeBase {
+        is_const: false,
+        decl_span: ZeroSpan::invalid(path),
+    };
+    [
+        ("char", IntType::char(base.clone())),
+        ("int", IntType::int(base.clone(), true)),
+        ("uint", IntType::int(base.clone(), false)),
+        ("int64_t", IntType::int64(base.clone(), true)),
+        ("uint64_t", IntType::int64(base.clone(), false)),
+        ("long", IntType::long(base.clone(), true)),
+        ("ulong", IntType::long(base.clone(), false)),
+        ("size_t", IntType::size_t(base.clone(), false)),
+        ("ssize_t", IntType::size_t(base, true)),
+    ].iter()
+        .map(|(name, ty)| (
+            name.to_string(),
+            Some(Arc::new(DMLConcreteType::Int(ty.clone())))))
+        .collect()
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Hash)]
+pub enum DMLStructLabel {
+    Labeled(DMLString),
+    Anonymous(u64),
+}
+
+impl DMLStructLabel {
+    pub fn new_from_maybe_string(s: Option<DMLString>) -> Self {
+        match s {
+            Some(label) => DMLStructLabel::Labeled(label),
+            None => DMLStructLabel::Anonymous(next_anon_id()),
+        }
+    }
+}
+
+// u64 should be more than large enough to generate unique IDs for even long-running langserver processes
+static ANON_ID_COUNTER: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(0);
+
+fn next_anon_id() -> u64 {
+    ANON_ID_COUNTER.fetch_add(1, std::sync::atomic::Ordering::Relaxed)
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Hash)]
 pub struct DMLStructType {
-    no_info: ZeroSpan,
+    pub base: TypeBase,
+    pub label: DMLStructLabel,
+    pub members: Vec<(Option<DMLString>, DMLType)>,
 }
+impl_trait_fns!(DMLStructType, DeclarationSpan, base, fn span(&self) -> &ZeroSpan);
 
+// For identification of structs, use covering-span (they dont always have a name decl)
+impl IdentitySpan for DMLStructType {
+    fn identity_span(&self) -> &ZeroSpan {
+        self.span()
+    }
+}
 impl DMLStructType {
-    pub fn span(&self) -> &ZeroSpan {
-        &self.no_info
+    pub fn equivalent(&self, other: &Self) -> bool {
+        self.base.equivalent(&other.base)
+            && self.label == other.label
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Hash)]
+pub struct DMLArrayType {
+    pub base: TypeBase,
+    pub typing: DMLType,
+    pub size: Option<u64>,
+}
+impl_trait_fns!(DMLArrayType, DeclarationSpan, base, fn span(&self) -> &ZeroSpan);
+impl DMLArrayType {
+    pub fn equivalent(&self, other: &Self) -> bool {
+        self.base.equivalent(&other.base)
+            && self.size == other.size
+            && dmltype_equivalent(&self.typing, &other.typing)
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Hash)]
+pub struct DMLPointerType {
+    pub base: TypeBase,
+    pub typing: DMLType,
+}
+impl_trait_fns!(DMLPointerType, DeclarationSpan, base, fn span(&self) -> &ZeroSpan);
+impl DMLPointerType {
+    pub fn equivalent(&self, other: &Self) -> bool {
+        self.base.equivalent(&other.base)
+            && dmltype_equivalent(&self.typing, &other.typing)
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Hash)]
+pub struct DMLFunctionType {
+    pub base: TypeBase,
+    pub arg_types: Vec<DMLType>,
+    pub vararg: bool,
+    // NOTE: Empty return type means an INVALID type, non-returning
+    // methods will get a function type with voidtype return
+    pub return_ty: DMLType,
+}
+impl_trait_fns!(DMLFunctionType, DeclarationSpan, base, fn span(&self) -> &ZeroSpan);
+impl DMLFunctionType {
+    pub fn equivalent(&self, other: &Self) -> bool {
+        self.base.equivalent(&other.base)
+            && self.arg_types.len() == other.arg_types.len()
+            && self.arg_types.iter().zip(
+                other.arg_types.iter()).all(
+                |(ty1, ty2)|dmltype_equivalent(ty1, ty2))
+            && dmltype_equivalent(&self.return_ty, &other.return_ty)
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Hash)]
+pub struct DMLVectorType {
+    pub base: TypeBase,
+    pub typing: DMLType,
+}
+impl_trait_fns!(DMLVectorType, DeclarationSpan, base, fn span(&self) -> &ZeroSpan);
+impl DMLVectorType {
+    pub fn equivalent(&self, other: &Self) -> bool {
+        self.base.equivalent(&other.base)
+            && dmltype_equivalent(&self.typing, &other.typing)
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Hash)]
+pub struct DMLLayoutType {
+    pub base: DMLStructType,
+    pub endianness: Option<Endianness>,
+}
+impl_trait_fns!(DMLLayoutType, DeclarationSpan, base, fn span(&self) -> &ZeroSpan);
+impl DMLLayoutType {
+    pub fn equivalent(&self, other: &Self) -> bool {
+        self.base.equivalent(&other.base)
+            && self.endianness == other.endianness
+    }
+}
+
+// NOTE: A TypeSequence is NOT the same as a SequenceType
+// A TypeSequence is heterogeneous and not something declared
+// in-code
+// TODO: How do handle semantic-only types?
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Hash)]
+pub struct DMLTypeSequence {
+    pub base: TypeBase,
+    pub types: Vec<DMLType>,
+}
+impl_trait_fns!(DMLTypeSequence, DeclarationSpan, base, fn span(&self) -> &ZeroSpan);
+impl DMLTypeSequence {
+    pub fn equivalent(&self, other: &Self) -> bool {
+        self.base.equivalent(&other.base)
+            && self.types.len() == other.types.len()
+            && self.types.iter().zip(other.types.iter())
+            .all(|(ty1, ty2)|dmltype_equivalent(ty1, ty2))
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Hash)]
+pub struct DMLSequenceType {
+    pub base: TypeBase,
+    pub trait_type: DMLTraitType,
+}
+impl_trait_fns!(DMLSequenceType, DeclarationSpan, base, fn span(&self) -> &ZeroSpan);
+impl DMLSequenceType {
+    pub fn equivalent(&self, other: &Self) -> bool {
+        self.base.equivalent(&other.base)
+            && self.trait_type.equivalent(&other.trait_type)
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Hash)]
+pub struct DMLHookType {
+    pub base: TypeBase,
+    pub arg_types: Vec<DMLType>,
+}
+impl_trait_fns!(DMLHookType, DeclarationSpan, base, fn span(&self) -> &ZeroSpan);
+impl DMLHookType {
+    pub fn equivalent(&self, other: &Self) -> bool {
+        self.base.equivalent(&other.base)
+            && self.arg_types.len() == other.arg_types.len()
+            && self.arg_types.iter().zip(other.arg_types.iter())
+            .all(|(ty1, ty2)|dmltype_equivalent(ty1, ty2))
+    }
+}
+
+/// A resolved def, maintaining info about the typedef that resolved it
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Hash)]
+pub struct DMLTypedefType {
+    // Use-site info (const and the like)
+    pub base: TypeBase,
+    // The typedef's name and the span of its declaration (used for
+    // goto-type-def).
+    pub decl_name: DMLString,
+    // Type the tpedef points to
+    pub underlying: DMLType,
+}
+impl_trait_fns!(DMLTypedefType, DeclarationSpan, base, fn span(&self) -> &ZeroSpan);
+impl DMLTypedefType {
+    pub fn equivalent(&self, other: &Self) -> bool {
+        self.base.equivalent(&other.base)
+            && self.decl_name.span == other.decl_name.span
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Hash)]
+pub struct DMLTraitType {
+    // use-site info
+    pub base: TypeBase,
+    pub decl_name: DMLString,
+}
+impl_trait_fns!(DMLTraitType, DeclarationSpan, base, fn span(&self) -> &ZeroSpan);
+
+// loc span is the location of the declaration
+impl LocationSpan for DMLTraitType {
+    fn loc_span(&self) -> &ZeroSpan {
+        &self.decl_name.span
+    }
+}
+
+impl IdentitySpan for DMLTraitType {
+    fn identity_span(&self) -> &ZeroSpan {
+        self.loc_span()
+    }
+}
+impl DMLTraitType {
+    pub fn equivalent(&self, other: &Self) -> bool {
+        self.base.equivalent(&other.base)
+            && self.decl_name.span == other.decl_name.span
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Hash)]
 pub enum DMLConcreteType {
-    BaseType(DMLBaseType),
+    // These are re-used directly from structure, as there is nothing to
+    // resolve in them
+    Void(VoidType),
+    Device(DeviceType),
+    Bool(BoolType),
+    EndianInt(EndianIntType),
+    Int(IntType),
+    Float(FloatType),
+    Double(DoubleType),
+    Bitfields(BitfieldsType),
+    // And these are the resolved results of structural types
+    Array(DMLArrayType),
+    Pointer(DMLPointerType),
+    Function(DMLFunctionType),
+    Vector(DMLVectorType),
+    Layout(DMLLayoutType),
+    Hook(DMLHookType),
+    TypeSequence(DMLTypeSequence),
+    Sequence(DMLSequenceType),
     StructType(DMLStructType),
+    // separated due to needing to maintain meta-info
+    Typedef(DMLTypedefType),
+    Trait(DMLTraitType),
+}
+
+impl From<DMLConcreteType> for DMLType {
+    fn from(fr: DMLConcreteType) -> DMLType {
+        Some(Arc::new(fr))
+    }
 }
 
 impl DMLConcreteType {
     pub fn span(&self) -> &ZeroSpan {
         match self {
-            DMLConcreteType::BaseType(b) => b.span(),
-            DMLConcreteType::StructType(s) => s.span(),
+            Self::Void(i) => i.span(),
+            Self::Device(i) => i.span(),
+            Self::Bool(i) => i.span(),
+            Self::EndianInt(i) => i.span(),
+            Self::Int(i) => i.span(),
+            Self::Float(i) => i.span(),
+            Self::Double(i) => i.span(),
+            Self::Bitfields(i) => i.span(),
+            Self::Array(i) => i.span(),
+            Self::Pointer(i) => i.span(),
+            Self::Function(i) => i.span(),
+            Self::Vector(i) => i.span(),
+            Self::Layout(i) => i.span(),
+            Self::Hook(i) => i.span(),
+            Self::TypeSequence(i) => i.span(),
+            Self::Sequence(i) => i.span(),
+            Self::StructType(i) => i.span(),
+            Self::Typedef(i) => i.span(),
+            Self::Trait(i) => i.span(),
         }
     }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub enum DMLResolvedType {
-    Actual(DMLConcreteType),
-    // In some cases, a type fails to resolve but we do not want to drop
-    // the thing that depends on it, in this case we provide the dummy variant
-    Dummy(ZeroSpan),
-}
 
-impl DMLResolvedType {
-    pub fn span(&self) -> &ZeroSpan {
+    pub fn peel_one(&self) -> Option<&DMLType> {
         match self {
-            DMLResolvedType::Actual(typ) => typ.span(),
-            DMLResolvedType::Dummy(span) => span,
+            Self::Typedef(td) => Some(&td.underlying),
+            Self::Array(a) => Some(&a.typing),
+            Self::Pointer(p) => Some(&p.typing),
+            Self::Vector(v) => Some(&v.typing),
+            _ => None,
         }
     }
+}
+
+pub type DMLType = Option<Arc<DMLConcreteType>>;
 
-    pub fn is_dummy(&self) -> bool {
-        matches!(self, DMLResolvedType::Dummy(_))
+// Resolved a concrete type past typedefs
+fn fully_resolved(ty: &DMLType) -> &DMLType {
+    match ty {
+        Some(t) => match t.as_ref() {
+            DMLConcreteType::Typedef(td) => fully_resolved(&td.underlying),
+            _ => ty,
+        },
+        None => ty,
     }
+}
 
-    pub fn equivalent(&self, _: &DMLResolvedType) -> bool {
-        // TODO: actual type comparison beyond this
-        // Currently, we are using this only to typecheck arguments
-        // for method overrides, so returning true avoids
-        // false negatives
-        true
+pub fn dmltype_equivalent(ty1: &DMLType, ty2: &DMLType) -> bool {
+    match (fully_resolved(ty1), fully_resolved(ty2)) {
+        (Some(t1), Some(t2)) => t1.equivalent(t2),
+        // I think it is correct to say missing types are equivalent,
+        // so as to not report mismatching errors when there will be
+        // a report about the invalid type anyway
+        (_, _) => true,
     }
 }
 
-impl From<DMLConcreteType> for DMLResolvedType {
-    fn from(frm: DMLConcreteType) -> DMLResolvedType {
-        DMLResolvedType::Actual(frm)
+impl DMLConcreteType {
+    // Equivalent is a fairly strict comparison, not the same
+    // as a canstore
+    pub fn equivalent(&self, other: &Self) -> bool {
+        match (self, other) {
+            (Self::Void(i1), Self::Void(i2)) => i1.equivalent(i2),
+            (Self::Device(i1), Self::Device(i2)) => i1.equivalent(i2),
+            (Self::Bool(i1), Self::Bool(i2)) => i1.equivalent(i2),
+            (Self::EndianInt(i1), Self::EndianInt(i2)) => i1.equivalent(i2),
+            (Self::Int(i1), Self::Int(i2)) => i1.equivalent(i2),
+            (Self::Float(i1), Self::Float(i2)) => i1.equivalent(i2),
+            (Self::Double(i1), Self::Double(i2)) => i1.equivalent(i2),
+            (Self::Bitfields(i1), Self::Bitfields(i2)) => i1.equivalent(i2),
+            (Self::Array(i1), Self::Array(i2)) => i1.equivalent(i2),
+            (Self::Pointer(i1), Self::Pointer(i2)) => i1.equivalent(i2),
+            (Self::Function(i1), Self::Function(i2)) => i1.equivalent(i2),
+            (Self::Vector(i1), Self::Vector(i2)) => i1.equivalent(i2),
+            (Self::Layout(i1), Self::Layout(i2)) => i1.equivalent(i2),
+            (Self::Hook(i1), Self::Hook(i2)) => i1.equivalent(i2),
+            (Self::TypeSequence(i1), Self::TypeSequence(i2)) =>
+                i1.equivalent(i2),
+            (Self::Sequence(i1), Self::Sequence(i2)) => i1.equivalent(i2),
+            (Self::StructType(i1), Self::StructType(i2)) => i1.equivalent(i2),
+            (Self::Typedef(i1), Self::Typedef(i2)) => i1.equivalent(i2),
+            (Self::Trait(i1), Self::Trait(i2)) => i1.equivalent(i2),
+            (_, _) => false,
+        }
     }
 }
 
-pub fn eval_type(ast: &DMLType, _location: (), _scope: (),
-                 _in_extern: bool, _typename_hint: Option<&str>,
-                 _allow_void: bool)
-                 -> (Vec<DMLStructType>, DMLConcreteType) {
-    (vec![], DMLConcreteType::BaseType(DMLBaseType {
-        // TODO: replace with .span once types are concrete
-        no_info: *ast }))
+pub fn eval_type(ast: &UnresolvedType, global: &mut GlobalTypeStorage,
+                 in_extern: bool, _typename_hint: Option<&str>,
+                 _allow_void: bool, errors: &mut Vec<DMLError>)
+                 -> DMLType {
+    let mut resolving = ResolvingState::default();
+    ast.resolve(global, &mut resolving, in_extern, false, errors)
 }
 
-pub fn eval_type_simple(ast: &DMLType, location: (), scope: ())
-    -> (Vec<DMLStructType>, DMLConcreteType) {
-    eval_type(ast, location, scope, false, None, false)
+pub fn eval_type_simple(ast: &UnresolvedType, global: &mut GlobalTypeStorage,
+                        errors: &mut Vec<DMLError>) -> DMLType {
+    eval_type(ast, global, false, None, false, errors)
 }
diff --git a/src/lib.rs b/src/lib.rs
index 608d2c5..71e1e96 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -21,10 +21,10 @@
 // possible
 macro_rules! internal_error {
     ( $mess:expr, $( $arg:expr ),* ) => {
-        error!("Internal Error: {}", format!($mess, $( $arg ),*));
+        error!("Internal Error: {}", format!($mess, $( $arg ),*))
     };
     ( $mess:expr ) => {
-        error!("Internal Error: {}", $mess);
+        error!("Internal Error: {}", $mess)
     }
 }
 
diff --git a/src/server/dispatch.rs b/src/server/dispatch.rs
index 5e4ee43..d787895 100644
--- a/src/server/dispatch.rs
+++ b/src/server/dispatch.rs
@@ -98,6 +98,7 @@ macro_rules! define_dispatch_request_enum {
 define_dispatch_request_enum!(
     Completion,
     GotoDefinition,
+    GotoTypeDefinition,
     References,
     DocumentSymbolRequest,
     WorkspaceSymbolRequest,
diff --git a/src/server/mod.rs b/src/server/mod.rs
index f118491..6ec7e94 100644
--- a/src/server/mod.rs
+++ b/src/server/mod.rs
@@ -35,6 +35,7 @@ use lsp_types::{
     DeclarationCapability,
     HoverProviderCapability,
     ImplementationProviderCapability,
+    TypeDefinitionProviderCapability,
     InitializeResult, OneOf, ServerCapabilities,
     ServerInfo,
     TextDocumentSyncCapability,
@@ -590,6 +591,7 @@ impl<O: Output> LsService<O> {
                 requests::DocumentSymbolRequest,
                 requests::HoverRequest,
                 requests::GotoDefinition,
+                requests::GotoTypeDefinition,
                 requests::GotoDeclaration,
                 requests::References,
                 requests::Completion,
@@ -701,7 +703,8 @@ fn server_caps<O: Output>(_ctx: &ActionContext<O>) -> ServerCapabilities {
         hover_provider: Some(HoverProviderCapability::Simple(true)),
         completion_provider: None,
         definition_provider: Some(OneOf::Left(true)),
-        type_definition_provider: None,
+        type_definition_provider: Some(
+            TypeDefinitionProviderCapability::Simple(true)),
         implementation_provider: Some(
             ImplementationProviderCapability::Simple(true)),
         references_provider: None,
diff --git a/tests/error_reporting_tests.rs b/tests/error_reporting_tests.rs
new file mode 100644
index 0000000..bc333f8
--- /dev/null
+++ b/tests/error_reporting_tests.rs
@@ -0,0 +1,432 @@
+//  © 2024 Intel Corporation
+//  SPDX-License-Identifier: Apache-2.0 and MIT
+
+//! Fixtures declare the errors they expect via `@error` annotations, either
+//! as a trailing comment on the same line where the error's span is
+//! expected to start:
+//!
+//! ```dml
+//! param x default 1;
+//! param x default 2; // @error[7]="Name collision"
+//! ```
+//!
+//! or stacked on standalone comment lines directly above it (useful when
+//! multiple errors are expected on the same line/col):
+//!
+//! ```dml
+//! // @error[7]="Name collision"
+//! // @error[7]="Name collision"
+//! param x default 2;
+//! ```
+//!
+//! `[7]` is the 1-indexed column of the expected error's starting span, and
+//! the quoted string must appear as a substring of the error's
+//! description
+//!
+//! A diagnostic's `related` entries are declared with `@related[col]of[row]`
+//! where 'row' is the row where the annotation specifying the error it is
+//! related to is declared in the file. Or with '..of[row@file.dml]' when
+//! the original diagnostic is in a different file
+//!
+//! ```dml
+//! param x default 1; // @related[7]of[2]="Previously defined here"
+//! param x default 2; // @error[7]="Name collision"
+//! ```
+
+use std::collections::HashMap;
+use std::path::PathBuf;
+use std::str::FromStr;
+use std::sync::LazyLock;
+use std::time::SystemTime;
+
+use regex::Regex;
+
+use dls::actions::DeviceAnalysisJobOptions;
+use dls::analysis::{DMLError, DeviceAnalysis, IsolatedAnalysis};
+use dls::analysis::parsing::tree::ZeroSpan;
+use dls::actions::analysis_storage::TimestampedStorage;
+use dls::concurrency::JobStatusKeeper;
+use dls::file_management::CanonPath;
+use dls::vfs::TextFile;
+
+/// Returns all collected errors plus a map of filename -> raw file content
+/// (needed to resolve `@error`/`@related` annotations against). `filenames`
+/// must be non-empty; the first entry is the primary/device file that device
+/// analysis (if requested) is run for, with every other file included as an
+/// additional analysis base -- this lets a `related` diagnostic span into a
+/// companion file (see the module docs' `of[row@file]` syntax).
+#[track_caller]
+fn analyze_and_read_files(filenames: &[&str], run_device_analysis: bool) -> (Vec<DMLError>, HashMap<String, String>) {
+    assert!(!filenames.is_empty(), "at least one filename must be provided");
+    let base_dir = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("tests/test_files");
+    let (_keeper, status) = JobStatusKeeper::new();
+
+    let mut contents = HashMap::new();
+    let mut isolated_analyses = Vec::new();
+    for &filename in filenames {
+        let file_path = base_dir.join(filename);
+        let content = std::fs::read_to_string(&file_path)
+            .unwrap_or_else(|e| panic!("failed to read {}: {}", file_path.display(), e));
+
+        let canon_path = CanonPath::from_path_buf(file_path.clone())
+            .unwrap_or_else(|| panic!("failed to canonicalize path: {}", file_path.display()));
+
+        let text_file = TextFile::from_str(&content)
+            .unwrap_or_else(|_| panic!("failed to parse text file: {}", file_path.display()));
+
+        let isolated = IsolatedAnalysis::new(
+            &canon_path,
+            &file_path,
+            text_file,
+            status.clone(),
+        ).unwrap_or_else(|e| panic!("isolated analysis failed for {}: {:?}", filename, &e));
+
+        contents.insert(filename.to_string(), content);
+        isolated_analyses.push(isolated);
+    }
+
+    let primary = isolated_analyses[0].clone();
+    let mut errors: Vec<DMLError> = primary.errors.clone();
+
+    if run_device_analysis {
+        assert!(primary.toplevel.device.is_some(),
+                "{} must have a 'device' declaration to run device analysis",
+                filenames[0]);
+        let timestamp = SystemTime::UNIX_EPOCH;
+        // The device's own file must also be present among the "bases"
+        // (this is how the device's own templates/typedefs get registered,
+        // see `templates_from_device_and_bases`/`DeviceAnalysis::new`); any
+        // other supplied filenames are included the same way, so their
+        // declarations are visible too (e.g. as targets of `related` spans).
+        let timed_bases = isolated_analyses.into_iter()
+            .map(|stored| TimestampedStorage { timestamp, stored })
+            .collect();
+        let device_analysis = DeviceAnalysis::new(
+            primary,
+            timed_bases,
+            HashMap::default(),
+            DeviceAnalysisJobOptions { max_reference_cache_size: 0 },
+            status,
+        ).unwrap_or_else(|e| panic!("device analysis failed for {}: {:?}", filenames[0], &e));
+        // Remove minimal errors related to missing builtin files
+        errors.extend(device_analysis.errors.into_values().flatten()
+                      .filter(|e| !e.description.starts_with("Could not find file")));
+    }
+
+    (errors, contents)
+}
+
+/// A single `@error[col]="substring"` annotation.
+#[derive(Debug, Clone)]
+struct ExpectedError {
+    /// File this annotation was found in; the expected span must be in
+    /// this same file.
+    file: String,
+    /// 0-indexed line and column of the expected span
+    line: u32,
+    col: u32,
+    substring: String,
+    /// 0-indexed source line (within `file`) this annotation's comment was
+    /// physically written on (before stacked-comment redirection). Used as
+    /// an identifier so `@related` annotations can reference the specific
+    /// error they belong to.
+    annotated_at: u32,
+}
+
+/// A single `@related[col]of[row]` or `@related[col]of[row@file]` annotation,
+/// matched against an entry in a diagnostic's `related` list, by the related
+/// span's own line/col (not the main error's span).
+#[derive(Debug, Clone)]
+struct ExpectedRelated {
+    /// File this annotation was found in; the expected related span must be
+    /// in this same file.
+    file: String,
+    /// 0-indexed line and column of the expected related span
+    line: u32,
+    col: u32,
+    substring: String,
+    /// File of the owning `@error` annotation's `annotated_at` line.
+    /// Defaults to `file` (i.e. `of[row]` with no `@file` suffix means the
+    /// owning `@error` is in the same file as this `@related`).
+    of_file: String,
+    /// 0-indexed source line (within `of_file`) of the owning `@error`
+    /// annotation's `annotated_at`.
+    of_line: u32,
+}
+
+static ERROR_ANNOTATION_RE: LazyLock<Regex> = LazyLock::new(|| {
+    Regex::new(r#"@error\[(\d+)\]="([^"]*)""#).unwrap()
+});
+
+static RELATED_ANNOTATION_RE: LazyLock<Regex> = LazyLock::new(|| {
+    Regex::new(r#"@related\[(\d+)\]of\[(\d+)(?:@([A-Za-z0-9_./-]+))?\]="([^"]*)""#).unwrap()
+});
+
+/// Build a map from each line to the next non-comment, non-empty code line.
+fn build_next_code_line_map(lines: &[&str]) -> Vec<Option<u32>> {
+    let mut result = vec![None; lines.len()];
+    let mut next_code: Option<u32> = None;
+
+    for i in (0..lines.len()).rev() {
+        result[i] = next_code;
+        let trimmed = lines[i].trim();
+        if !trimmed.is_empty() && !trimmed.starts_with("//") {
+            next_code = Some(i as u32);
+        }
+    }
+
+    result
+}
+
+/// Annotations on a standalone comment line apply to the next actual code
+/// line, so multiple annotations can be stacked above it. The very first
+/// line is exempt: some diagnostics carry a synthetic span at the literal
+/// start of the file (e.g. a builtin type with no real declaration site),
+/// which can only be targeted by an annotation placed on line 1 itself.
+fn effective_line(line_idx: usize, lines: &[&str], next_code_line: &[Option<u32>]) -> u32 {
+    let line_num = line_idx as u32;
+    if line_num > 0 && lines[line_idx].trim().starts_with("//") {
+        next_code_line[line_idx].unwrap_or(line_num)
+    } else {
+        line_num
+    }
+}
+
+fn parse_expected_errors(filename: &str, content: &str) -> Vec<ExpectedError> {
+    let mut expected = vec![];
+    let lines: Vec<&str> = content.lines().collect();
+    let next_code_line = build_next_code_line_map(&lines);
+
+    for (line_idx, line) in lines.iter().enumerate() {
+        let eff_line = effective_line(line_idx, &lines, &next_code_line);
+        for cap in ERROR_ANNOTATION_RE.captures_iter(line) {
+            let col: u32 = cap[1].parse().expect("annotation column must be a number");
+            expected.push(ExpectedError {
+                file: filename.to_string(),
+                line: eff_line,
+                // Annotation columns are 1-indexed in source, compensate
+                col: col - 1,
+                substring: cap[2].to_string(),
+                annotated_at: line_idx as u32,
+            });
+        }
+    }
+    expected
+}
+
+fn parse_expected_related(filename: &str, content: &str) -> Vec<ExpectedRelated> {
+    let mut expected = vec![];
+    let lines: Vec<&str> = content.lines().collect();
+    let next_code_line = build_next_code_line_map(&lines);
+
+    for (line_idx, line) in lines.iter().enumerate() {
+        let eff_line = effective_line(line_idx, &lines, &next_code_line);
+        for cap in RELATED_ANNOTATION_RE.captures_iter(line) {
+            let col: u32 = cap[1].parse().expect("annotation column must be a number");
+            let of_line: u32 = cap[2].parse().expect("annotation 'of' line must be a number");
+            let of_file = cap.get(3).map_or_else(|| filename.to_string(), |m| m.as_str().to_string());
+            expected.push(ExpectedRelated {
+                file: filename.to_string(),
+                line: eff_line,
+                col: col - 1,
+                substring: cap[4].to_string(),
+                of_file,
+                // 'of[X]' is also a 1-indexed source line, compensate
+                of_line: of_line - 1,
+            });
+        }
+    }
+    expected
+}
+
+#[track_caller]
+fn assert_errors_match(actual: &[DMLError], contents: &HashMap<String, String>) {
+    let base_dir = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("tests/test_files");
+
+    let mut expected_errors = vec![];
+    let mut expected_related = vec![];
+    for (filename, content) in contents {
+        expected_errors.extend(parse_expected_errors(filename, content));
+        expected_related.extend(parse_expected_related(filename, content));
+    }
+
+    // Match main errors against actual diagnostics, tracking which actual
+    // error matched which annotation so its (file, annotated_at) can be
+    // used to scope the related-info matching below.
+    let mut claimed_actual = vec![false; actual.len()];
+    let mut owner_of_actual: Vec<Option<(String, u32)>> = vec![None; actual.len()];
+    let mut missing_errors = vec![];
+
+    for exp in &expected_errors {
+        let exp_path = base_dir.join(&exp.file);
+        let found = actual.iter().enumerate().position(|(i, e)| {
+            !claimed_actual[i]
+                && e.span.path() == exp_path
+                && e.span.range.row_start.0 == exp.line
+                && e.span.range.col_start.0 == exp.col
+                && e.description.contains(&exp.substring)
+        });
+        match found {
+            Some(i) => {
+                claimed_actual[i] = true;
+                owner_of_actual[i] = Some((exp.file.clone(), exp.annotated_at));
+            }
+            None => missing_errors.push(exp.clone()),
+        }
+    }
+    let unexpected_errors: Vec<&DMLError> = actual.iter().enumerate()
+        .filter(|(i, _)| !claimed_actual[*i])
+        .map(|(_, e)| e)
+        .collect();
+
+    // Match related entries: each is only matched against `@related`
+    // annotations whose 'of[row(@file)]' refers to the same `@error`
+    // annotation that the owning actual error was matched against.
+    let mut claimed_related = vec![false; expected_related.len()];
+    let mut unexpected_related: Vec<(&ZeroSpan, &String)> = vec![];
+
+    for (i, e) in actual.iter().enumerate() {
+        let owner = &owner_of_actual[i];
+        for (span, msg) in &e.related {
+            let found = expected_related.iter().enumerate().position(|(j, exp)| {
+                !claimed_related[j]
+                    && matches!(owner, Some((f, l)) if *f == exp.of_file && *l == exp.of_line)
+                    && span.path() == base_dir.join(&exp.file)
+                    && span.range.row_start.0 == exp.line
+                    && span.range.col_start.0 == exp.col
+                    && msg.contains(&exp.substring)
+            });
+            match found {
+                Some(j) => claimed_related[j] = true,
+                None => unexpected_related.push((span, msg)),
+            }
+        }
+    }
+    let missing_related: Vec<&ExpectedRelated> = expected_related.iter().enumerate()
+        .filter(|(j, _)| !claimed_related[*j])
+        .map(|(_, exp)| exp)
+        .collect();
+
+    if missing_errors.is_empty() && unexpected_errors.is_empty()
+        && missing_related.is_empty() && unexpected_related.is_empty() {
+        return;
+    }
+
+    let mut msg = String::new();
+    if !missing_errors.is_empty() {
+        msg.push_str("Missing errors (annotation with no matching actual error):\n");
+        for exp in &missing_errors {
+            msg.push_str(&format!(
+                "  - {} line {} col {}: expected substring \"{}\"\n",
+                exp.file, exp.line + 1, exp.col + 1, exp.substring));
+        }
+    }
+    if !unexpected_errors.is_empty() {
+        msg.push_str("Unexpected/unclaimed errors (no matching @error annotation):\n");
+        for e in &unexpected_errors {
+            msg.push_str(&format!(
+                "  - {} line {} col {}: {}\n",
+                e.span.path().display(),
+                e.span.range.row_start.0 + 1,
+                e.span.range.col_start.0 + 1,
+                e.description));
+        }
+    }
+    if !missing_related.is_empty() {
+        msg.push_str("Missing related info (annotation with no matching actual related entry):\n");
+        for exp in &missing_related {
+            msg.push_str(&format!(
+                "  - {} line {} col {} of[{}@{}]: expected substring \"{}\"\n",
+                exp.file, exp.line + 1, exp.col + 1, exp.of_line + 1, exp.of_file, exp.substring));
+        }
+    }
+    if !unexpected_related.is_empty() {
+        msg.push_str("Unexpected/unclaimed related info (no matching @related annotation):\n");
+        for (span, message) in &unexpected_related {
+            msg.push_str(&format!(
+                "  - {} line {} col {}: {}\n",
+                span.path().display(),
+                span.range.row_start.0 + 1,
+                span.range.col_start.0 + 1,
+                message));
+        }
+    }
+    panic!("{}", msg);
+}
+
+#[track_caller]
+fn check_isolated_errors(filenames: &[&str]) {
+    let (errors, contents) = analyze_and_read_files(filenames, false);
+    assert_errors_match(&errors, &contents);
+}
+
+#[track_caller]
+fn check_device_errors(filenames: &[&str]) {
+    let (errors, contents) = analyze_and_read_files(filenames, true);
+    assert_errors_match(&errors, &contents);
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_bad_version_error() {
+        check_isolated_errors(&["errors_bad_version.dml"]);
+    }
+
+    #[test]
+    fn test_isolated_misc_errors() {
+        check_isolated_errors(&["errors_isolated_misc.dml"]);
+    }
+
+    #[test]
+    fn test_object_param_errors() {
+        check_device_errors(&["errors_object_params.dml"]);
+    }
+
+    #[test]
+    fn test_template_trait_errors() {
+        check_device_errors(&["errors_templates_traits.dml"]);
+    }
+
+    #[test]
+    fn test_template_cycle() {
+        check_device_errors(&["errors_template_cycle.dml"]);
+    }
+
+    #[test]
+    fn test_typedef_cyclic_errors() {
+        check_device_errors(&["errors_typedef_cyclic.dml"]);
+    }
+
+    #[test]
+    fn test_method_errors() {
+        check_device_errors(&["errors_methods.dml"]);
+    }
+
+    #[test]
+    fn test_extern_typedef_unknown_type_errors() {
+        check_device_errors(&["extern_typedef_unknown_type.dml"]);
+    }
+
+    #[test]
+    fn test_duplicate_typedef_name_errors() {
+        check_device_errors(&["errors_typedef_duplicate.dml"]);
+    }
+
+    #[test]
+    fn test_typedef_self_ref_pointer_errors() {
+        check_device_errors(&["errors_typedef_self_ref_pointer.dml"]);
+    }
+
+    #[test]
+    fn test_unknown_type_errors() {
+        check_device_errors(&["errors_unknown_type.dml"]);
+    }
+
+    #[test]
+    fn test_builtin_type_lookup_errors() {
+        check_device_errors(&["errors_builtin_type_lookup.dml"]);
+    }
+}
diff --git a/tests/lsp_lookup_tests.rs b/tests/lsp_lookup_tests.rs
index 23748a3..7330a81 100644
--- a/tests/lsp_lookup_tests.rs
+++ b/tests/lsp_lookup_tests.rs
@@ -23,7 +23,8 @@ use dls::span::{Position, ZeroIndexed};
 use dls::file_management::{CanonPath, PathResolver};
 use dls::server::io::Output;
 use dls::actions::semantic_lookup::{definitions_at_fp, declarations_at_fp,
-                                       implementations_at_fp, references_at_fp, DLSLimitation};
+                                       implementations_at_fp, references_at_fp,
+                                       type_definitions_at_fp, DLSLimitation};
 
 // Mock output for testing
 #[derive(Clone, Debug)]
@@ -64,6 +65,7 @@ enum OperationType {
     GotoDeclaration, // @goto-decl -> name
     GotoImplementation, // @goto-impl -> name,name,...
     FindReferences,  // @goto-ref -> name,name,...
+    GotoTypeDefinition, // @goto-type-def -> name
 }
 
 impl std::fmt::Display for OperationType {
@@ -73,6 +75,7 @@ impl std::fmt::Display for OperationType {
             OperationType::GotoDeclaration => write!(f, "goto-decl"),
             OperationType::GotoImplementation => write!(f, "goto-impl"),
             OperationType::FindReferences => write!(f, "goto-ref"),
+            OperationType::GotoTypeDefinition => write!(f, "goto-type-def"),
         }
     }
 }
@@ -209,13 +212,13 @@ static RE_LOC: LazyLock<Regex> = LazyLock::new(|| {
 
 /// Regex for operation annotations
 static RE_OP: LazyLock<Regex> = LazyLock::new(|| {
-    Regex::new(r"@(goto-def-decl|goto-def|goto-decl|goto-impl|goto-ref)\[(\d+)\]->([^@]*)").unwrap()
+    Regex::new(r"@(goto-def-decl|goto-def|goto-decl|goto-impl|goto-ref|goto-type-def)\[(\d+)\]->([^@]*)").unwrap()
 });
 
 /// Regex for an operation annotation that is missing the required column bracket.
 /// Used for detecting test-writer errors
 static RE_OP_NO_COL: LazyLock<Regex> = LazyLock::new(|| {
-    Regex::new(r"@(goto-def-decl|goto-def|goto-decl|goto-impl|goto-ref)->").unwrap()
+    Regex::new(r"@(goto-def-decl|goto-def|goto-decl|goto-impl|goto-ref|goto-type-def)->").unwrap()
 });
 
 /// Catch-all regex for any `@word[...]->` or `@word->` pattern.
@@ -301,6 +304,7 @@ fn parse_annotations(content: &str, file_path: Option<PathBuf>) -> (Vec<Location
                 "goto-def-decl" => vec![OperationType::GotoDefinition, OperationType::GotoDeclaration],
                 "goto-impl" => vec![OperationType::GotoImplementation],
                 "goto-ref" => vec![OperationType::FindReferences],
+                "goto-type-def" => vec![OperationType::GotoTypeDefinition],
                 other => unreachable!("regex does not match '{}'", other),
             };
             let col: u32 = cap[2].parse()
@@ -326,11 +330,11 @@ fn parse_annotations(content: &str, file_path: Option<PathBuf>) -> (Vec<Location
         for cap in RE_UNKNOWN_OP.captures_iter(line) {
             let tag = &cap[1];
             let known = matches!(tag,
-                "goto-def" | "goto-decl" | "goto-def-decl" | "goto-impl" | "goto-ref");
+                "goto-def" | "goto-decl" | "goto-def-decl" | "goto-impl" | "goto-ref" | "goto-type-def");
             if !known {
                 panic!(
                     "unrecognized annotation '@{}' on line {}, \
-                     expected one of: @goto-def, @goto-decl, @goto-def-decl, @goto-impl, @goto-ref\n  \
+                     expected one of: @goto-def, @goto-decl, @goto-def-decl, @goto-impl, @goto-ref, @goto-type-def\n  \
                      line {}: {}",
                     tag, line_num + 1, line_num + 1, line.trim()
                 );
@@ -761,8 +765,6 @@ fn setup_test(filenames: &[&str]) -> TestSetup {
 mod tests {
     use super::*;
 
-    /// Signature shared by all semantic-lookup entry points
-    /// (`definitions_at_fp`, `declarations_at_fp`, ...).
     type LookupFn = fn(&InitActionContext<MockOutput>,
                       &ZeroFilePosition,
                       &mut HashSet<DLSLimitation>)
@@ -824,7 +826,9 @@ mod tests {
             .expect("Failed to get device analysis");
 
         // Check that symbols were created
-        let all_symbols: Vec<_> = device_analysis.symbol_info.all_symbols().collect();
+        let all_symbols: Vec<_> = device_analysis.symbol_info
+            .all_symbols()
+            .collect();
         assert!(!all_symbols.is_empty(), "No symbols were created");
     }
 
@@ -994,7 +998,22 @@ mod tests {
         run_annotation_tests(&setup.ctx, &setup.main_file, setup.annotations);
     }
 
-    /// Helper function to run annotation tests.
+    #[test]
+    fn test_type_lookup() {
+        init_logging();
+        let setup = setup_test(&["type_lookup.dml"]);
+
+        run_annotation_tests(&setup.ctx, &setup.main_file, setup.annotations);
+    }
+
+    #[test]
+    fn test_type_variable_name_shadowing() {
+        init_logging();
+        let setup = setup_test(&["type_shadow_lookup.dml"]);
+
+        run_annotation_tests(&setup.ctx, &setup.main_file, setup.annotations);
+    }
+
     #[track_caller]
     fn run_annotation_tests(
         ctx: &InitActionContext<MockOutput>,
@@ -1005,6 +1024,7 @@ mod tests {
         let mut goto_decl = Vec::new();
         let mut goto_impl = Vec::new();
         let mut find_refs = Vec::new();
+        let mut goto_type_def = Vec::new();
 
         for ann in &annotations {
             match ann.operation_type {
@@ -1012,6 +1032,7 @@ mod tests {
                 OperationType::GotoDeclaration => goto_decl.push(ann),
                 OperationType::GotoImplementation => goto_impl.push(ann),
                 OperationType::FindReferences => find_refs.push(ann),
+                OperationType::GotoTypeDefinition => goto_type_def.push(ann),
             }
         }
 
@@ -1038,6 +1059,7 @@ mod tests {
         run(&goto_decl, OperationType::GotoDeclaration,    declarations_at_fp);
         run(&goto_impl, OperationType::GotoImplementation, implementations_at_fp);
         run(&find_refs, OperationType::FindReferences,     references_at_fp);
+        run(&goto_type_def, OperationType::GotoTypeDefinition, type_definitions_at_fp);
 
         assert!(all_sections.is_empty(),
             "{} annotation failure(s):\n\n{}",
@@ -1045,8 +1067,8 @@ mod tests {
             all_sections.join("\n\n"));
     }
 
-    /// Path of `p` relative to `tests/test_files/`, or the full path
-    /// string if it falls outside that directory.
+    // Path of `p` relative to `tests/test_files/`, or the full path
+    // string if it falls outside that directory.
     fn rel_to_test_files(p: &Path) -> String {
         let base = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
             .join("tests/test_files");
@@ -1061,22 +1083,17 @@ mod tests {
         }
     }
 
-    /// Check whether a span matches a target's expected position and file.
     fn target_matches_span(target: &ResolvedTarget, span: &ZeroSpan) -> bool {
         let position_matches = span.range.row_start.0 == target.line()
             && span.range.col_start.0 == target.col();
         position_matches && rel_to_test_files(&span.path()) == target.filename()
     }
 
-    /// Format a human-readable display string for a missing target.
     fn format_missing_target(target: &ResolvedTarget) -> String {
         format!("'{}' @ {}:{}:{}",
                 target.name, target.filename(), target.line() + 1, target.col() + 1)
     }
 
-    /// Match targets against returned spans.
-    /// Returns `(found_positive, found_questionable, failures)` where
-    /// `failures` are formatted error strings.
     fn match_targets_against_spans(
         targets: &[ResolvedTarget],
         spans: &[&ZeroSpan],
@@ -1115,12 +1132,6 @@ mod tests {
         (found_positive, found_questionable, failures)
     }
 
-    /// Deduplicate spans and optionally filter to the query file.
-    /// Returns the relevant (deduplicated) spans.
-    ///
-    /// An empty target list asserts "no results anywhere", so we keep spans
-    /// from every file in that case. With non-empty same-file-only targets,
-    /// we only assert about same-file spans and ignore cross-file results.
     fn deduplicate_spans<'a>(
         spans: &'a [ZeroSpan],
         ann: &ResolvedAnnotation,
@@ -1129,6 +1140,7 @@ mod tests {
         let query_file_path = ann.location.file_path.as_deref().unwrap_or(test_file);
         let query_rel = rel_to_test_files(query_file_path);
         let has_cross_file_targets = ann.targets.iter().any(|t| t.filename() != query_rel);
+        // keep all files if cross-targeting exists or targets is empty
         let keep_all_files = has_cross_file_targets || ann.targets.is_empty();
         let mut seen_positions = HashSet::new();
         let mut result = Vec::new();
@@ -1145,11 +1157,6 @@ mod tests {
         result
     }
 
-    /// Find extra (unexpected) spans that don't match any positive or
-    /// questionable target. Negated targets are excluded — they're already
-    /// validated in `match_targets_against_spans`. Questionable targets are
-    /// treated like positive ones here so we don't double-report a known bug.
-    /// Returns formatted display strings for each extra span.
     fn find_extra_spans(ann: &ResolvedAnnotation, spans: &[&ZeroSpan]) -> Vec<String> {
         spans.iter()
             .filter(|span| !ann.targets.iter().any(|t|
@@ -1162,8 +1169,6 @@ mod tests {
             .collect()
     }
 
-    /// Evaluate a single annotation against lookup results.
-    /// Returns Ok(summary) on success, Err(detail) on failure.
     fn evaluate_annotation(
         ann: &ResolvedAnnotation,
         spans: &[ZeroSpan],
@@ -1220,9 +1225,7 @@ mod tests {
         Err(detail)
     }
 
-    /// Generic function to test any goto operation.
-    /// Accepts a pre-filtered slice of annotations.
-    /// Returns `(failure_count, total_count, failure_details)`
+    // Returns `(failure_count, total_count, failure_details)`
     fn test_goto_operation(
         ctx: &InitActionContext<MockOutput>,
         test_file: &Path,
@@ -1260,8 +1263,6 @@ mod tests {
         (fail_count, test_annotations.len(), failures)
     }
 
-    /// Goto-def on an `import "./..."` in a device file should resolve to
-    /// the imported commoncode file (relative path resolution).
     #[test]
     fn test_goto_def_on_relative_import() {
         init_logging();
@@ -1271,8 +1272,6 @@ mod tests {
         run_annotation_tests(&setup.ctx, &setup.main_file, setup.annotations);
     }
 
-    /// Goto-def on an import in a commoncode file should also resolve, so
-    /// chains of commoncode-only imports can be navigated.
     #[test]
     fn test_goto_def_on_commoncode_import() {
         init_logging();
@@ -1286,10 +1285,6 @@ mod tests {
         run_annotation_tests(&setup.ctx, &setup.main_file, setup.annotations);
     }
 
-    /// When the same commoncode file is imported by two devices that
-    /// resolve a given import string to different files (via different
-    /// include paths), goto-def on that import should return BOTH
-    /// resolutions.
     #[test]
     fn test_goto_def_on_import_resolves_per_device_context() {
         init_logging();
@@ -1313,9 +1308,6 @@ mod tests {
         let expected_b = CanonPath::from_path_buf(
             base_dir.join("imports/test3_inc_b/shared.dml")).unwrap();
 
-        // The import we're testing is `import "shared.dml";` on line 6
-        // (0-indexed row 5) of test3_common.dml. Position the lookup inside
-        // the quoted import string (col 11, 1-indexed => col 10, 0-indexed).
         let common_path = base_dir.join("imports/test3_common.dml");
         let file_pos = make_file_position(&common_path, 5, 10);
 
@@ -1337,8 +1329,6 @@ mod tests {
                    "expected exactly 2 targets, got {}: {:?}",
                    spans.len(), result_paths);
 
-        // Each result span should be at (0,0) per definitions_at_fp's
-        // file-reference contract.
         for span in &spans {
             assert_eq!(span.range.row_start.0, 0);
             assert_eq!(span.range.col_start.0, 0);
diff --git a/tests/test_files/errors_bad_version.dml b/tests/test_files/errors_bad_version.dml
new file mode 100644
index 0000000..5036889
--- /dev/null
+++ b/tests/test_files/errors_bad_version.dml
@@ -0,0 +1,7 @@
+//  © 2024 Intel Corporation
+//  SPDX-License-Identifier: Apache-2.0 and MIT
+
+// Isolated-analysis error: the language server only supports DML 1.4.
+
+// @error[1]="only supports DML 1.4"
+dml 1.3;
diff --git a/tests/test_files/errors_builtin_type_lookup.dml b/tests/test_files/errors_builtin_type_lookup.dml
new file mode 100644
index 0000000..5336c32
--- /dev/null
+++ b/tests/test_files/errors_builtin_type_lookup.dml
@@ -0,0 +1,16 @@
+//  © 2024 Intel Corporation
+//  SPDX-License-Identifier: Apache-2.0 and MIT
+
+dml 1.4;
+
+device builtin_type_lookup_test;
+
+session char v_char;
+session int v_int;
+session uint v_uint;
+session long v_long;
+session ulong v_ulong;
+session size_t v_size_t;
+session ssize_t v_ssize_t;
+session uint64_t v_uint64_t;
+session int64_t v_int64_t;
diff --git a/tests/test_files/errors_isolated_misc.dml b/tests/test_files/errors_isolated_misc.dml
new file mode 100644
index 0000000..e5acbb9
--- /dev/null
+++ b/tests/test_files/errors_isolated_misc.dml
@@ -0,0 +1,36 @@
+//  © 2024 Intel Corporation
+//  SPDX-License-Identifier: Apache-2.0 and MIT
+
+// Check some specific errors created in structural parsing
+
+dml 1.4;
+
+device errors_isolated_misc_test;
+
+// @error[19]="Bitfields size cannot be > than 64 bits"
+typedef bitfields 128 {
+    uint32 hi @ [31:0];
+} too_wide_bitfields_t;
+
+// @error[19]="Bitfields size cannot be less than 1"
+typedef bitfields 0 {
+    uint32 lo @ [31:0];
+} too_narrow_bitfields_t;
+
+typedef bitfields 32 {
+    // @error[5]="Bitfield type must be simple integer type"
+    uint32 *bad_field @ [31:0];
+} bad_field_type_bitfields_t;
+
+bank errors_isolated_misc_bank {
+    // @error[33]="Too large integer constant"
+    param too_large_int default 99999999999999999999; 
+    // NOTE: the minus is not part of the integer constant, so this overflows the same as above
+    // @error[34]="Too large integer constant"
+    param too_small_int default -99999999999999999999;
+
+    method use_invalid_log_kind() {
+        // @error[13]="Invalid log kind"
+        log blah: "this log kind does not exist";
+    }
+}
diff --git a/tests/test_files/errors_methods.dml b/tests/test_files/errors_methods.dml
new file mode 100644
index 0000000..8657a53
--- /dev/null
+++ b/tests/test_files/errors_methods.dml
@@ -0,0 +1,82 @@
+//  © 2024 Intel Corporation
+//  SPDX-License-Identifier: Apache-2.0 and MIT
+
+// Checks for errors related to method arguments, returns, and overrides
+
+dml 1.4;
+
+device errors_methods_test;
+
+// @error[31]="Cannot use anonymous struct type in argument type"
+method anon_struct_arg_method(struct { int x; } bad_arg) {
+}
+
+// @error[40]="Cannot use anonymous struct type in return type"
+method anon_struct_return_method() -> (struct { int x; }) {
+}
+
+template method_mismatch_base_tmpl {
+    // @related[12]of[36]="Overridden method declared here"
+    method shared_target() default {
+    }
+    // @related[12]of[42]="Throwing method declared here"
+    method throwing_target() throws default {
+    }
+    // @related[32]of[48]="Corresponding argument declared here"
+    method arg_type_target(int a) default {
+    }
+    method return_type_target() -> (int) default { // @related[37]of[54]="Corresponding return type declared here"
+        return 0;
+    }
+    // @related[12]of[61]="Attempted to override this declaration"
+    method not_default_target() {}
+}
+
+template bad_shared_override_tmpl is method_mismatch_base_tmpl {
+    // @error[19]="Shared method cannot override non-shared method"
+    shared method shared_target() {
+    }
+}
+
+template bad_throw_override_tmpl is method_mismatch_base_tmpl {
+    // @error[12]="Non-throwing method cannot override throwing method"
+    method throwing_target() {
+    }
+}
+
+template bad_arg_type_override_tmpl is method_mismatch_base_tmpl {
+    // @error[33]="Mismatching argument type in method override"
+    method arg_type_target(bool a) {
+    }
+}
+
+template bad_return_type_override_tmpl is method_mismatch_base_tmpl {
+    // @error[37]="Mismatching return type in method override"
+    method return_type_target() -> (bool) {
+        return false;
+    }
+}
+
+template bad_default_decl is method_mismatch_base_tmpl {
+    // @error[12]="This method attempts to override a non-default method"
+    method not_default_target() {}
+}
+
+typedef int my_int_t;
+typedef int other_int_t;
+
+template typedef_equivalence_base_tmpl {
+    method typedef_return_target() -> (my_int_t) default {
+        return 0;
+    }
+    method typedef_arg_target(my_int_t a) default {
+    }
+}
+
+template typedef_equivalence_override_tmpl is typedef_equivalence_base_tmpl {
+    method typedef_return_target() -> (int) {
+        return 0;
+    }
+    method typedef_arg_target(other_int_t a) {
+    }
+}
diff --git a/tests/test_files/errors_object_params.dml b/tests/test_files/errors_object_params.dml
new file mode 100644
index 0000000..17116f0
--- /dev/null
+++ b/tests/test_files/errors_object_params.dml
@@ -0,0 +1,37 @@
+//  © 2024 Intel Corporation
+//  SPDX-License-Identifier: Apache-2.0 and MIT
+
+// Device-analysis level errors relating to parameter assignments
+
+dml 1.4;
+
+device errors_object_params_test;
+
+template overridable_param_tmpl {
+    // @error[5]="Definition overrides non-default parameter"
+    // @related[5]of[11]="Non-default declaration here"
+    param overridden_param = 1;
+}
+
+// @error[6]="No assignment to parameter 'no_assignment_param'"
+bank errors_object_params_bank is overridable_param_tmpl {
+    // @related[5]of[16]="Declared here"
+    param no_assignment_param;
+
+    // @error[5]="Conflicting assignments to parameter 'conflicting_param'"
+    param conflicting_param default 1;
+    // @related[5]of[21]="Conflicting assignment here"
+    param conflicting_param default 2;
+
+    // @error[11]="Name collision in declaration on 'dup_name'"
+    param dup_name default 1;
+    // @related[17]of[26]="also declared here"
+    session int dup_name;
+
+    // @error[5]="Invalid assignment to auto-parameter 'auto_param'"
+    param auto_param auto;
+    // @related[5]of[31]="Conflicting assignment here"
+    param auto_param default 5;
+
+    param overridden_param default 2;
+}
diff --git a/tests/test_files/errors_template_cycle.dml b/tests/test_files/errors_template_cycle.dml
new file mode 100644
index 0000000..90e27f8
--- /dev/null
+++ b/tests/test_files/errors_template_cycle.dml
@@ -0,0 +1,13 @@
+//  © 2024 Intel Corporation
+//  SPDX-License-Identifier: Apache-2.0 and MIT
+
+dml 1.4;
+
+device template_cycle_test;
+
+// @error[1]="Template inherits from itself, either directly or indirectly"
+template a is b { // @related[15]of[8]="Imported through here"
+}
+
+template b is a { // @related[15]of[8]="Imported through here"
+}
diff --git a/tests/test_files/errors_templates_traits.dml b/tests/test_files/errors_templates_traits.dml
new file mode 100644
index 0000000..f077800
--- /dev/null
+++ b/tests/test_files/errors_templates_traits.dml
@@ -0,0 +1,57 @@
+//  © 2024 Intel Corporation
+//  SPDX-License-Identifier: Apache-2.0 and MIT
+
+// Device-level errors for template and type name collisions
+
+dml 1.4;
+
+device errors_templates_traits_test;
+
+// @related[10]of[13]="Previously defined here"
+// @related[10]of[19]="Template defined here"
+template dup_template_name_tmpl { param p default 1; }
+// @error[10]="Duplicate template name; 'dup_template_name_tmpl'"
+template dup_template_name_tmpl { param p default 2; }
+
+typedef int dup_typedef_name_t; // @related[13]of[17]="Previously defined here"
+typedef int dup_typedef_name_t; // @error[13]="Duplicate typedef name; 'dup_typedef_name_t'"
+
+typedef int dup_template_name_tmpl; // @error[13]="Typedef name 'dup_template_name_tmpl' collides with a template name"
+
+template member_collision_tmpl {
+    // @error[11]="Name collision on 'collide_name'"
+    param collide_name: int default 1;
+    session int collide_name; // @related[17]of[22]="Previously defined here"
+}
+
+template method_override_base_tmpl {
+    // @related[12]of[41]="Attempted to override this declaration"
+    // @related[12]of[53]="Attempted to override this declaration"
+    // @related[12]of[52]="Overridden method declared here"
+    method non_default_method() {
+        log info: "base";
+    }
+    // @related[12]of[48]="Overridden definition here"
+    method shared_m() default {
+        log info: "base default";
+    }
+}
+
+template method_override_bad_tmpl is method_override_base_tmpl {
+    // @error[12]="This method attempts to override a non-default method"
+    method non_default_method() {
+        log info: "override";
+    }
+}
+
+template abstract_override_bad_tmpl is method_override_base_tmpl {
+    method shared_m(); // @error[12]="Abstract method cannot override another method"
+}
+
+template wrong_arity_override_tmpl is method_override_base_tmpl {
+    // @error[12]="Wrong number of arguments in method override"
+    // @error[12]="This method attempts to override a non-default method"
+    method non_default_method(int extra_arg) {
+        log info: "override";
+    }
+}
diff --git a/tests/test_files/errors_typedef_cyclic.dml b/tests/test_files/errors_typedef_cyclic.dml
new file mode 100644
index 0000000..e83d69e
--- /dev/null
+++ b/tests/test_files/errors_typedef_cyclic.dml
@@ -0,0 +1,13 @@
+//  © 2024 Intel Corporation
+//  SPDX-License-Identifier: Apache-2.0 and MIT
+
+dml 1.4;
+
+device typedef_cycle_test;
+
+// @related[9]of[11]="Cyclic reference occurs here"
+// @related[13]of[11]="through 'foo' here"
+typedef bar foo;
+typedef foo bar; // @error[13]="Typedef 'bar' is cyclically defined"
+
+saved foo v;
diff --git a/tests/test_files/errors_typedef_duplicate.dml b/tests/test_files/errors_typedef_duplicate.dml
new file mode 100644
index 0000000..7827cae
--- /dev/null
+++ b/tests/test_files/errors_typedef_duplicate.dml
@@ -0,0 +1,20 @@
+//  © 2024 Intel Corporation
+//  SPDX-License-Identifier: Apache-2.0 and MIT
+
+// Exercises the duplicate-typedef-name diagnostic added alongside the type
+// lookup system: declaring two typedefs with the same name in the same
+// device must be reported as an error rather than silently overwriting the
+// first declaration (which would otherwise make the first typedef's
+// declaration site unreachable for goto-def/ref purposes).
+
+dml 1.4;
+
+device typedef_duplicate_test;
+
+typedef uint32 dup_t; // @related[16]of[18]="Previously defined here"
+
+// Second declaration of the same name; this should raise a
+// "Duplicate typedef name" error pointing back at the first declaration.
+typedef uint8 dup_t; // @error[15]="Duplicate typedef name; 'dup_t'"
+
+saved dup_t v;
diff --git a/tests/test_files/errors_typedef_self_ref_pointer.dml b/tests/test_files/errors_typedef_self_ref_pointer.dml
new file mode 100644
index 0000000..3e66eaa
--- /dev/null
+++ b/tests/test_files/errors_typedef_self_ref_pointer.dml
@@ -0,0 +1,17 @@
+//  © 2024 Intel Corporation
+//  SPDX-License-Identifier: Apache-2.0 and MIT
+
+// A struct that references itself only through a pointer member (a common
+// linked-list-node pattern, e.g. `simics/util/hashtab.dml`'s
+// `ht_entry_common_t`). This must not be reported as a cyclic typedef.
+
+dml 1.4;
+
+device typedef_self_ref_pointer_test;
+
+typedef struct {
+    node_t *next;
+    int val;
+} node_t;
+
+saved node_t v;
diff --git a/tests/test_files/errors_unknown_type.dml b/tests/test_files/errors_unknown_type.dml
new file mode 100644
index 0000000..54cceef
--- /dev/null
+++ b/tests/test_files/errors_unknown_type.dml
@@ -0,0 +1,10 @@
+//  © 2024 Intel Corporation
+//  SPDX-License-Identifier: Apache-2.0 and MIT
+
+dml 1.4;
+
+device unknown_type_test;
+
+// @error[7]="Unknown type 'this_type_does_not_exist'"
+// @error[7]="Unknown type 'this_type_does_not_exist'"
+saved this_type_does_not_exist v;
diff --git a/tests/test_files/extern_typedef_unknown_type.dml b/tests/test_files/extern_typedef_unknown_type.dml
new file mode 100644
index 0000000..256392a
--- /dev/null
+++ b/tests/test_files/extern_typedef_unknown_type.dml
@@ -0,0 +1,15 @@
+//  © 2024 Intel Corporation
+//  SPDX-License-Identifier: Apache-2.0 and MIT
+
+dml 1.4;
+
+device extern_typedef_unknown_type_test;
+
+extern typedef some_c_only_type extern_alias_t; // @error[16]="Unknown type 'some_c_only_type'"
+
+typedef some_c_only_type non_extern_alias_t; // @error[9]="Unknown type 'some_c_only_type'"
+
+typedef unknown_c_type helper_t; // @error[9]="Unknown type 'unknown_c_type'"
+
+// Typedef depending on typedef of unknown type does not error
+extern typedef helper_t extern_other_alias_t;
diff --git a/tests/test_files/goto_impl_test.dml b/tests/test_files/goto_impl_test.dml
index 01ab14d..7a1e298 100644
--- a/tests/test_files/goto_impl_test.dml
+++ b/tests/test_files/goto_impl_test.dml
@@ -27,7 +27,7 @@ bank container_bank {
 }
 
 // @loc[10]=multi_use_tmpl
-template multi_use_template { // @goto-impl[10]->bank_multi_inst,group_multi_inst,reg_multi_inst @goto-ref[10]->bank_multi_inst,group_multi_inst,reg_multi_inst,!multi_use_template_as_type_1,!multi_use_template_as_type_2
+template multi_use_template { // @goto-impl[10]->bank_multi_inst,group_multi_inst,reg_multi_inst @goto-ref[10]->bank_multi_inst,group_multi_inst,reg_multi_inst,multi_use_template_as_type_1,multi_use_template_as_type_2
     param common default 42;
 }
 
@@ -45,14 +45,12 @@ bank container_for_register {
     }
 }
 
-// Make sure goto-impl on template does not find template as type reference
+// Make sure goto-impl on templates does not find template-as-type references
 method m() {
-    // TODO: Type references currently do not work
     // @loc[11]=multi_use_template_as_type_1 @loc[52]=multi_use_template_as_type_2
-    local multi_use_template m = cast(group_multi, multi_use_template); // @goto-def-decl[11]->!multi_use_tmpl @goto-def-decl[52]->!multi_use_tmpl 
+    local multi_use_template m = cast(group_multi, multi_use_template); // @goto-def-decl[11]->multi_use_tmpl @goto-def-decl[52]->multi_use_tmpl 
 }
 
-// Test 3: Multi-template in each - requires ALL templates
 template multi_test_a {
     param a_val default 1;
 }
@@ -65,7 +63,6 @@ template multi_test_c {
     param c_val default 3;
 }
 
-// Positive: Object with both templates A and B
 bank both_templates is (multi_test_a, multi_test_b) { // @goto-impl[6]->both_ab_ineach,split_ineach
     param single_custom default 300;
 }
@@ -75,7 +72,6 @@ in each (multi_test_a, multi_test_b) {
     param another_shared default 201;
 }
 
-// Positive: Object with all three templates
 bank has_all_three is (multi_test_a, multi_test_b, multi_test_c) { // @goto-impl[6]->three_ineach,both_ab_ineach,split_ineach
     param complete default 888;
 }
@@ -85,17 +81,14 @@ in each (multi_test_a, multi_test_b, multi_test_c) {
     param needs_all_three default 777;
 }
 
-// Negative: Object with only one template (missing multi_test_b)
 bank only_one_template is multi_test_a { // @goto-impl[6]->
     param only_a_param default 400;
 }
 
-// Negative: Object with two templates but missing the third
 bank has_only_two is (multi_test_a, multi_test_b) { // @goto-impl[6]->both_ab_ineach,split_ineach
     param incomplete default 666;
 }
 
-// Test 4: Split object declaration with multiple templates
 group split_group is multi_test_a { // // @goto-impl[7]->both_ab_ineach,split_ineach
     param first_part default 100;
 }
diff --git a/tests/test_files/type_lookup.dml b/tests/test_files/type_lookup.dml
new file mode 100644
index 0000000..79aaa36
--- /dev/null
+++ b/tests/test_files/type_lookup.dml
@@ -0,0 +1,110 @@
+//  © 2024 Intel Corporation
+//  SPDX-License-Identifier: Apache-2.0 and MIT
+
+dml 1.4;
+
+device type_test_device;
+
+// @loc[10]=template_t_def
+template template_t { // @goto-ref[10]->template_t_use
+    // @loc[11]=template_t_foo_field_def
+    param foo: int; // @goto-ref[11]->template_t_foo_field_use,template_t_foo_field_use_2
+    // @loc[17]=template_t_bar_field_def
+    session int bar; // @goto-ref[17]->template_t_bar_field_use
+}
+
+// @loc[16]=register_addr_t_def
+typedef uint32 register_addr_t; // @goto-ref[16]->register_addr_t_use_saved,register_addr_t_use_arg
+
+typedef struct {
+    // @loc[12]=packet_addr_field_def
+    uint32 addr; // @goto-ref[12]->packet_addr_field_use,packet_addr_field_use_2,packet_addr_field_use_3,packet_addr_field_use_4
+    // @loc[12]=packet_size_field_def
+    uint32 size; // @goto-ref[12]->packet_size_field_use,packet_size_field_use_2
+    uint8 data[16];
+// @loc[3]=packet_t_def
+} packet_t; // @goto-ref[3]->packet_t_use_arg,packet_t_use_saved,packet_t_use_ptr,packet_t_use_arr,packet_t_use_local
+
+saved register_addr_t current_addr; // @loc[7]=register_addr_t_use_saved @loc[23]=current_addr_def @goto-def-decl[7]->register_addr_t_def @goto-type-def[23]->register_addr_t_def @goto-ref[23]->current_addr_use_1,current_addr_use_2
+
+// @loc[7]=packet_t_use_saved
+// @loc[16]=last_packet_def
+saved packet_t last_packet; // @goto-def-decl[7]->packet_t_def @goto-type-def[16]->packet_t_def @goto-ref[16]->last_packet_use,last_packet_use_2
+
+// @loc[9]=template_t_use
+// @loc[20]=T_def
+session template_t T; // @goto-def-decl[9]->template_t_def @goto-ref[20]->T_use_1,T_use_2,T_use_3 @goto-type-def[20]->template_t_def
+
+// @loc[9]=packet_t_use_ptr
+// @loc[19]=packet_ptr_def
+session packet_t *packet_ptr; // @goto-def-decl[9]->packet_t_def @goto-type-def[19]->packet_t_def @goto-ref[19]->packet_ptr_use
+
+// @loc[9]=packet_t_use_arr
+// @loc[18]=packet_arr_def
+session packet_t packet_arr[2]; // @goto-def-decl[9]->packet_t_def @goto-type-def[18]->packet_t_def @goto-ref[18]->packet_arr_use
+
+// @loc[8]=process_method_def
+method process( // @goto-ref[8]->process_method_use
+    // @loc[5]=packet_t_use_arg
+    // @loc[14]=pkt_arg_def
+    packet_t pkt, // @goto-ref[14]->pkt_arg_use_1,pkt_arg_use_2,pkt_arg_use_3,pkt_arg_use_4
+    // @loc[5]=register_addr_t_use_arg
+    // @loc[21]=base_addr_arg_def
+    register_addr_t base_addr // @goto-ref[21]->base_addr_arg_use_1,base_addr_arg_use_2
+) {
+    // @loc[5]=current_addr_use_1
+    // @loc[20]=base_addr_arg_use_1
+    current_addr = base_addr; // @goto-def-decl[5]->current_addr_def @goto-def-decl[20]->base_addr_arg_def
+
+    // @loc[20]=pkt_arg_use_1
+    // @loc[24]=packet_addr_field_use
+    // @loc[31]=base_addr_arg_use_2
+    // @loc[5]=current_addr_use_2
+    current_addr = pkt.addr + base_addr; // @goto-def-decl[5]->current_addr_def @goto-def-decl[20]->pkt_arg_def @goto-def-decl[24]->packet_addr_field_def @goto-def-decl[31]->base_addr_arg_def
+
+    // @loc[34]=pkt_arg_use_2
+    // @loc[38]=packet_addr_field_use_2
+    // @loc[44]=pkt_arg_use_3
+    // @loc[48]=packet_size_field_use
+    log info: "addr=%d size=%d", pkt.addr, pkt.size; // @goto-def-decl[34]->pkt_arg_def @goto-def-decl[38]->packet_addr_field_def @goto-def-decl[44]->pkt_arg_def @goto-def-decl[48]->packet_size_field_def
+
+    // @loc[5]=last_packet_use
+    // @loc[19]=pkt_arg_use_4
+    last_packet = pkt; // @goto-def-decl[5]->last_packet_def @goto-def-decl[19]->pkt_arg_def @goto-type-def[5]->packet_t_def @goto-type-def[19]->packet_t_def
+}
+
+method kickoff() {
+    // @loc[5]=process_method_use
+    // @loc[13]=last_packet_use_2
+    process(last_packet, 0); // @goto-def-decl[5]->process_method_def @goto-def-decl[13]->last_packet_def
+
+    // @loc[21]=T_use_1
+    // @loc[23]=template_t_foo_field_use
+    log info: "%d", T.foo; // @goto-def-decl[21]->T_def @goto-def-decl[23]->template_t_foo_field_def
+
+    // @loc[9]=T_use_2
+    // @loc[11]=template_t_foo_field_use_2
+    if (T.foo == 0) { } // @goto-def-decl[9]->T_def @goto-def-decl[11]->template_t_foo_field_def
+
+    // @loc[21]=T_use_3
+    // @loc[23]=template_t_bar_field_use
+    log info: "%d", T.bar; // @goto-def-decl[21]->T_def @goto-def-decl[23]->template_t_bar_field_def
+}
+
+method type_coverage_extra() {
+    // @loc[5]=packet_ptr_use
+    // @loc[16]=packet_addr_field_use_3
+    packet_ptr.addr = 1; // @goto-def-decl[5]->packet_ptr_def @goto-def-decl[16]->packet_addr_field_def @goto-type-def[5]->packet_t_def
+
+    // @loc[5]=packet_arr_use
+    // @loc[19]=packet_size_field_use_2
+    packet_arr[0].size = 2; // @goto-def-decl[5]->packet_arr_def @goto-def-decl[19]->packet_size_field_def
+
+    // @loc[11]=packet_t_use_local
+    // @loc[20]=local_packet_def
+    local packet_t local_packet; // @goto-def-decl[11]->packet_t_def @goto-ref[20]->local_packet_use
+
+    // @loc[5]=local_packet_use
+    // @loc[18]=packet_addr_field_use_4
+    local_packet.addr = 3; // @goto-def-decl[5]->local_packet_def @goto-def-decl[18]->packet_addr_field_def @goto-type-def[5]->packet_t_def
+}
diff --git a/tests/test_files/type_shadow_lookup.dml b/tests/test_files/type_shadow_lookup.dml
new file mode 100644
index 0000000..899b308
--- /dev/null
+++ b/tests/test_files/type_shadow_lookup.dml
@@ -0,0 +1,27 @@
+//  © 2024 Intel Corporation
+//  SPDX-License-Identifier: Apache-2.0 and MIT
+
+// check that variable names and type names do not conflict
+dml 1.4;
+
+device type_shadow_test;
+
+// @loc[16]=packet_t_type_def
+typedef uint32 packet_t; // @goto-ref[16]->packet_t_type_use_saved,packet_t_type_use_local
+
+// @loc[7]=packet_t_type_use_saved
+// @loc[16]=packet_t_var_def
+saved packet_t packet_t; // @goto-def-decl[7]->packet_t_type_def @goto-type-def[16]->packet_t_type_def @goto-ref[16]->packet_t_var_use_1,packet_t_var_use_2
+
+method touch() {
+    // @loc[5]=packet_t_var_use_1
+    packet_t = 42; // @goto-def-decl[5]->packet_t_var_def
+
+    // @loc[11]=packet_t_type_use_local
+    // @loc[20]=local_pkt_def
+    local packet_t local_pkt = 7; // @goto-def-decl[11]->packet_t_type_def @goto-ref[20]->local_pkt_use
+
+    // @loc[5]=packet_t_var_use_2
+    // @loc[16]=local_pkt_use
+    packet_t = local_pkt; // @goto-def-decl[5]->packet_t_var_def @goto-def-decl[16]->local_pkt_def
+}