diff --git a/compiler/plc_ast/src/pre_processor.rs b/compiler/plc_ast/src/pre_processor.rs
index ea265cba080..e4da030420b 100644
--- a/compiler/plc_ast/src/pre_processor.rs
+++ b/compiler/plc_ast/src/pre_processor.rs
@@ -1,258 +1,370 @@
 // Copyright (c) 2020 Ghaith Hachem and Mathias Rieder
 
-use rustc_hash::FxHashMap;
+use rustc_hash::{FxHashMap, FxHashSet};
 
 use plc_util::convention::internal_type_name;
 
 use crate::{
     ast::{
         flatten_expression_list, Assignment, AstFactory, AstNode, AstStatement, CompilationUnit,
-        ConfigVariable, DataType, DataTypeDeclaration, LinkageType, Operator, Pou, UserTypeDeclaration,
-        Variable, VariableBlock, VariableBlockType,
+        ConfigVariable, DataType, DataTypeDeclaration, Interface, LinkageType, Operator, Pou,
+        UserTypeDeclaration, Variable, VariableBlock, VariableBlockType,
     },
     literals::AstLiteral,
+    mut_visitor::{AstVisitorMut, WalkerMut},
     provider::IdProvider,
     try_from,
 };
 use plc_source::source_location::SourceLocation;
 
-pub fn pre_process(unit: &mut CompilationUnit, mut id_provider: IdProvider) {
-    //process all local variables from POUs
-    for pou in unit.pous.iter_mut() {
-        //Find all generic types in that pou
-        let generic_types = preprocess_generic_structs(pou);
-        unit.user_types.extend(generic_types);
+/// Pre-processes a compilation unit, extracting inline type definitions,
+/// initializing enum elements, and creating backing globals for hardware access.
+pub fn pre_process(unit: &mut CompilationUnit, id_provider: IdProvider) {
+    PreProcessor::new(id_provider).visit_compilation_unit(unit);
+}
 
-        process_pou_variables(pou, &mut unit.user_types);
-    }
+/// A mutable AST visitor that performs pre-processing transformations.
+///
+/// Follows the [`AstVisitorMut`] pattern (see also `InheritanceLowerer`, `PropertyLowerer`)
+/// to walk the compilation unit and transform it in place:
+///
+/// - Extracts inline type definitions from variables into named [`UserTypeDeclaration`]s
+/// - Generates types for generic POU parameters
+/// - Creates backing global variables for IEC hardware access declarations (`AT %IX…`)
+/// - Initializes enum elements with auto-incrementing values
+struct PreProcessor {
+    id_provider: IdProvider,
+    /// Tracks which hardware-backing globals have been created to prevent duplicates.
+    known_hw_globals: FxHashSet<String>,
+    /// New types accumulated during the walk, flushed to `unit.user_types` afterward.
+    new_types: Vec<UserTypeDeclaration>,
+    /// Hardware-access backing globals accumulated during the walk.
+    mangled_globals: Vec<Variable>,
+    /// Name of the current containing scope (`"global"`, POU name, or struct name).
+    current_container: String,
+    /// Linkage of the current scope.
+    current_linkage: LinkageType,
+    /// Whether we are inside a POU (suppresses hardware-access processing for local variables).
+    in_pou: bool,
+}
 
-    for interface in unit.interfaces.iter_mut().flat_map(|it| &mut it.methods) {
-        process_pou_variables(interface, &mut unit.user_types);
+impl PreProcessor {
+    fn new(id_provider: IdProvider) -> Self {
+        Self {
+            id_provider,
+            known_hw_globals: FxHashSet::default(),
+            new_types: Vec::new(),
+            mangled_globals: Vec::new(),
+            current_container: "global".to_string(),
+            current_linkage: LinkageType::Internal,
+            in_pou: false,
+        }
     }
 
-    //process all variables from GVLs
-    process_global_variables(unit, &mut id_provider);
-    process_var_config_variables(unit);
+    /// Registers a [`DataTypeDeclaration::Definition`] as a named user type in [`Self::new_types`].
+    ///
+    /// If `decl` is not a `Definition` (e.g. already a `Reference`), this is a no-op.
+    fn register_extracted_type(&mut self, decl: DataTypeDeclaration, name: String, linkage: LinkageType) {
+        if let DataTypeDeclaration::Definition { mut data_type, location, scope } = decl {
+            data_type.set_name(name);
+            self.new_types.push(UserTypeDeclaration {
+                data_type: *data_type,
+                initializer: None,
+                location,
+                scope,
+                linkage,
+            });
+        }
+    }
 
-    //process all variables in dataTypes
-    let mut new_types = vec![];
-    for dt in unit.user_types.iter_mut() {
-        {
-            match &mut dt.data_type {
-                DataType::StructType { name, variables, .. } => {
-                    let name: &str = name.as_ref().map(|it| it.as_str()).unwrap_or("undefined");
-                    variables.iter_mut().filter(|it| should_generate_implicit_type(it)).for_each(|var| {
-                        pre_process_variable_data_type(name, var, &mut new_types, dt.linkage)
-                    });
-                }
-                DataType::ArrayType { name, referenced_type, .. }
-                | DataType::PointerType { name, referenced_type, .. }
-                    if should_generate_implicit(referenced_type) =>
-                {
-                    let name: &str = name.as_ref().map(|it| it.as_str()).unwrap_or("undefined");
-
-                    let type_name = internal_type_name("", name);
-                    let type_ref = DataTypeDeclaration::Reference {
-                        referenced_type: type_name.clone(),
-                        location: SourceLocation::internal(), //return_type.get_location(),
-                    };
-                    let datatype = std::mem::replace(referenced_type, Box::new(type_ref));
-                    if let DataTypeDeclaration::Definition { mut data_type, location, scope } = *datatype {
-                        data_type.set_name(type_name);
-                        add_nested_datatypes(name, &mut data_type, &mut new_types, &location, dt.linkage);
-                        let data_type = UserTypeDeclaration {
-                            data_type: *data_type,
-                            initializer: None,
-                            location,
-                            scope,
-                            linkage: dt.linkage,
-                        };
-                        new_types.push(data_type);
-                    }
-                }
-                DataType::EnumType { elements, .. }
-                    if matches!(elements.stmt, AstStatement::EmptyStatement { .. }) =>
-                {
-                    //avoid empty statements, just use an empty expression list to make it easier to work with
-                    let _ = std::mem::replace(&mut elements.stmt, AstStatement::ExpressionList(vec![]));
-                }
-                DataType::EnumType { elements: original_elements, name: Some(enum_name), .. }
-                    if !matches!(original_elements.stmt, AstStatement::EmptyStatement { .. }) =>
-                {
-                    let mut last_name: Option<String> = None;
-
-                    fn extract_flat_ref_name(statement: &AstNode) -> &str {
-                        statement.get_flat_reference_name().expect("expected assignment")
-                    }
-
-                    let initialized_enum_elements = flatten_expression_list(original_elements)
-                        .iter()
-                        .map(|it| {
-                            try_from!(it, Assignment).map_or_else(
-                                || (extract_flat_ref_name(it), None, it.get_location()),
-                                |Assignment { left, right }| {
-                                    (
-                                        extract_flat_ref_name(left.as_ref()),
-                                        Some(*right.clone()),
-                                        it.get_location(),
-                                    )
-                                },
-                            )
-                        })
-                        .map(|(element_name, initializer, location)| {
-                            let enum_literal = initializer.unwrap_or_else(|| {
-                                build_enum_initializer(&last_name, &location, &mut id_provider, enum_name)
-                            });
-                            last_name = Some(element_name.to_string());
-                            AstFactory::create_assignment(
-                                AstFactory::create_member_reference(
-                                    AstFactory::create_identifier(
-                                        element_name,
-                                        &location,
-                                        id_provider.next_id(),
-                                    ),
-                                    None,
-                                    id_provider.next_id(),
-                                ),
-                                enum_literal,
-                                id_provider.next_id(),
-                            )
-                        })
-                        .collect::<Vec<AstNode>>();
-                    // if the enum is empty, we dont change anything
-                    if !initialized_enum_elements.is_empty() {
-                        // we can safely unwrap because we checked the vec
-                        let start_loc =
-                            initialized_enum_elements.first().expect("non empty vec").get_location();
-                        let end_loc =
-                            initialized_enum_elements.iter().last().expect("non empty vec").get_location();
-                        //swap the expression list with our new Assignments
-                        let expression = AstFactory::create_expression_list(
-                            initialized_enum_elements,
-                            start_loc.span(&end_loc),
-                            id_provider.next_id(),
-                        );
-                        let _ = std::mem::replace(original_elements, expression);
-                    }
-                }
-                _ => {}
-            }
+    /// Extracts the inner type of an array or pointer when it is an inline [`DataTypeDeclaration::Definition`],
+    /// replacing it with a [`DataTypeDeclaration::Reference`] and pushing the extracted type to [`Self::new_types`].
+    fn extract_nested_type(&mut self, name: &Option<String>, referenced_type: &mut Box<DataTypeDeclaration>) {
+        if !should_generate_implicit(referenced_type) {
+            return;
         }
+        // Convention: nested extracted types are named `{container}_` (matches the old
+        // `add_nested_datatypes` behaviour; see also plc_util/src/convention.rs).
+        let container = name.as_deref().unwrap_or("undefined");
+        let type_name = format!("{container}_");
+        let type_ref = DataTypeDeclaration::Reference {
+            referenced_type: type_name.clone(),
+            location: SourceLocation::internal(),
+        };
+        let old = std::mem::replace(referenced_type.as_mut(), type_ref);
+        self.register_extracted_type(old, type_name, self.current_linkage);
     }
-    unit.user_types.append(&mut new_types);
-}
 
-fn process_pou_variables(pou: &mut Pou, user_types: &mut Vec<UserTypeDeclaration>) {
-    let local_variables = pou
-        .variable_blocks
-        .iter_mut()
-        .flat_map(|it| it.variables.iter_mut())
-        .filter(|it| should_generate_implicit_type(it));
+    /// Initializes enum elements with auto-incrementing values.
+    ///
+    /// Elements without an explicit initializer receive `previous + 1` (or `0` for the first).
+    fn initialize_enum_elements(&mut self, enum_name: &mut str, original_elements: &mut AstNode) {
+        let mut last_name: Option<String> = None;
+
+        fn extract_flat_ref_name(statement: &AstNode) -> &str {
+            statement.get_flat_reference_name().expect("expected assignment")
+        }
 
-    for var in local_variables {
-        pre_process_variable_data_type(pou.name.as_str(), var, user_types, pou.linkage)
+        let id_provider = &mut self.id_provider;
+
+        let initialized_enum_elements = flatten_expression_list(original_elements)
+            .iter()
+            .map(|it| {
+                try_from!(it, Assignment).map_or_else(
+                    || (extract_flat_ref_name(it), None, it.get_location()),
+                    |Assignment { left, right }| {
+                        (extract_flat_ref_name(left.as_ref()), Some(*right.clone()), it.get_location())
+                    },
+                )
+            })
+            .map(|(element_name, initializer, location)| {
+                let enum_literal = initializer.unwrap_or_else(|| {
+                    build_enum_initializer(&last_name, &location, id_provider, enum_name)
+                });
+                last_name = Some(element_name.to_string());
+                AstFactory::create_assignment(
+                    AstFactory::create_member_reference(
+                        AstFactory::create_identifier(element_name, &location, id_provider.next_id()),
+                        None,
+                        id_provider.next_id(),
+                    ),
+                    enum_literal,
+                    id_provider.next_id(),
+                )
+            })
+            .collect::<Vec<AstNode>>();
+
+        if !initialized_enum_elements.is_empty() {
+            let start_loc = initialized_enum_elements.first().expect("non empty vec").get_location();
+            let end_loc = initialized_enum_elements.iter().last().expect("non empty vec").get_location();
+            let expression = AstFactory::create_expression_list(
+                initialized_enum_elements,
+                start_loc.span(&end_loc),
+                id_provider.next_id(),
+            );
+            *original_elements = expression;
+        }
     }
 
-    //Generate implicit type for returns
-    preprocess_return_type(pou, user_types);
-}
+    /// Creates backing globals for `VAR_CONFIG` hardware addresses.
+    fn process_var_config(&mut self, unit: &CompilationUnit) {
+        for ConfigVariable { data_type, address, .. } in &unit.var_config {
+            let AstStatement::HardwareAccess(hardware) = &address.stmt else {
+                unreachable!("Must be parsed as hardware access")
+            };
 
-fn process_global_variables(unit: &mut CompilationUnit, id_provider: &mut IdProvider) {
-    let mut mangled_globals = Vec::new();
+            if hardware.is_template() {
+                continue;
+            }
 
-    for (linkage, global_var) in
-        unit.global_vars.iter_mut().flat_map(|block| block.variables.iter_mut().map(|it| (block.linkage, it)))
-    {
-        let ref_ty = global_var.data_type_declaration.get_inner_pointer_ty();
+            let name = hardware.get_mangled_variable_name();
+            if !self.known_hw_globals.insert(name.clone()) {
+                continue;
+            }
 
-        if should_generate_implicit_type(global_var) {
-            pre_process_variable_data_type("global", global_var, &mut unit.user_types, linkage)
+            self.mangled_globals.push(Variable {
+                name,
+                data_type_declaration: data_type.get_inner_pointer_ty().unwrap_or(data_type.clone()),
+                initializer: None,
+                address: None,
+                location: address.get_location(),
+            });
         }
+    }
+}
 
-        // In any case, we have to inject initializers into aliased hardware access variables
-        if let Some(ref node) = global_var.address {
-            if let AstStatement::HardwareAccess(hardware) = &node.stmt {
-                let name = hardware.get_mangled_variable_name();
+impl AstVisitorMut for PreProcessor {
+    fn visit_compilation_unit(&mut self, unit: &mut CompilationUnit) {
+        // Seed known hardware globals from existing globals so re-runs don't produce duplicates.
+        self.known_hw_globals = unit
+            .global_vars
+            .iter()
+            .flat_map(|block| &block.variables)
+            .filter(|var| {
+                var.name.starts_with("__PI_")
+                    || var.name.starts_with("__M_")
+                    || var.name.starts_with("__G_")
+            })
+            .map(|var| var.name.clone())
+            .collect();
+
+        // Walk the compilation unit: globals → user_types → pous → implementations → interfaces
+        unit.walk(self);
+
+        // Process VAR_CONFIG variables (not part of the default walk)
+        self.process_var_config(unit);
+
+        // Fixup: process any newly generated types that themselves need processing
+        // (e.g. an extracted struct whose members have inline types, or a nested array).
+        // The loop converges because each iteration only generates simpler (flatter) types.
+        while !self.new_types.is_empty() {
+            let mut batch = std::mem::take(&mut self.new_types);
+            for ut in &mut batch {
+                self.visit_user_type_declaration(ut);
+            }
+            unit.user_types.extend(batch);
+        }
 
-                // %I*: DWORD; should not be declared at this stage, it is just skipped
-                if hardware.is_template() {
-                    continue;
-                }
+        // Flush all accumulated hardware-access backing globals
+        update_generated_globals(unit, std::mem::take(&mut self.mangled_globals));
+    }
 
-                let mangled_initializer = AstFactory::create_member_reference(
-                    AstFactory::create_identifier(&name, SourceLocation::internal(), id_provider.next_id()),
-                    None,
-                    id_provider.next_id(),
-                );
+    fn visit_pou(&mut self, pou: &mut Pou) {
+        let prev_container = std::mem::replace(&mut self.current_container, pou.name.clone());
+        let prev_linkage = std::mem::replace(&mut self.current_linkage, pou.linkage);
+        let prev_in_pou = std::mem::replace(&mut self.in_pou, true);
+
+        // Generate types for generic parameters and replace generic names in variable types
+        if !pou.generics.is_empty() {
+            let mut generics = FxHashMap::default();
+            for binding in &pou.generics {
+                let new_name = format!("__{}__{}", pou.name, binding.name); // TODO: Naming convention (see plc_util/src/convention.rs)
+                self.new_types.push(UserTypeDeclaration {
+                    data_type: DataType::GenericType {
+                        name: new_name.clone(),
+                        generic_symbol: binding.name.clone(),
+                        nature: binding.nature,
+                    },
+                    initializer: None,
+                    scope: Some(pou.name.clone()),
+                    location: pou.location.clone(),
+                    linkage: pou.linkage,
+                });
+                generics.insert(binding.name.clone(), new_name);
+            }
+            for var in pou.variable_blocks.iter_mut().flat_map(|it| it.variables.iter_mut()) {
+                replace_generic_type_name(&mut var.data_type_declaration, &generics);
+            }
+            if let Some(rt) = pou.return_type.as_mut() {
+                replace_generic_type_name(rt, &generics);
+            }
+        }
 
-                global_var.initializer = Some(mangled_initializer);
+        // Walk variable blocks → visit_variable handles implicit type extraction
+        for block in &mut pou.variable_blocks {
+            self.visit_variable_block(block);
+        }
 
-                let internal_mangled_var = Variable {
-                    name,
-                    data_type_declaration: ref_ty.unwrap_or(global_var.data_type_declaration.clone()),
-                    initializer: None,
-                    address: None,
-                    location: node.location.clone(),
+        // Extract implicit return type
+        if let Some(return_type) = &pou.return_type {
+            if should_generate_implicit(return_type) {
+                let type_name = format!("__{}_return", &pou.name);
+                let type_ref = DataTypeDeclaration::Reference {
+                    referenced_type: type_name.clone(),
+                    location: return_type.get_location(),
                 };
-                mangled_globals.push(internal_mangled_var);
+                if let Some(old) = pou.return_type.replace(type_ref) {
+                    self.register_extracted_type(old, type_name, pou.linkage);
+                }
             }
         }
+
+        self.current_container = prev_container;
+        self.current_linkage = prev_linkage;
+        self.in_pou = prev_in_pou;
+    }
+
+    fn visit_interface(&mut self, interface: &mut Interface) {
+        for method in &mut interface.methods {
+            self.visit_pou(method);
+        }
     }
 
-    update_generated_globals(unit, mangled_globals);
-}
+    fn visit_variable_block(&mut self, block: &mut VariableBlock) {
+        // For non-POU blocks (globals), take linkage from the block itself
+        if !self.in_pou {
+            self.current_linkage = block.linkage;
+        }
+        block.walk(self);
+    }
 
-fn process_var_config_variables(unit: &mut CompilationUnit) {
-    let variables = unit.var_config.iter().filter_map(|ConfigVariable { data_type, address, .. }| {
-        let AstStatement::HardwareAccess(hardware) = &address.stmt else {
-            unreachable!("Must be parsed as hardware access")
-        };
+    fn visit_variable(&mut self, variable: &mut Variable) {
+        // Capture inner pointer type before any replacement
+        let ref_ty = variable.data_type_declaration.get_inner_pointer_ty();
 
+        // Extract inline type definitions into named types
+        if should_generate_implicit(&variable.data_type_declaration) {
+            let new_type_name =
+                internal_type_name(&format!("{}_", &self.current_container), &variable.name);
+            let old = variable.replace_data_type_with_reference_to(new_type_name.clone());
+            self.register_extracted_type(old, new_type_name, self.current_linkage);
+        }
+
+        // Create backing globals for hardware-access variables (globals and struct members only).
+        // POU-local variables and template addresses (%I* : DWORD) are skipped.
+        if self.in_pou {
+            return;
+        }
+        let Some(ref node) = variable.address else { return };
+        let AstStatement::HardwareAccess(hardware) = &node.stmt else { return };
         if hardware.is_template() {
-            return None;
+            return;
         }
 
-        // Check if the mangled variable already exists in any of the global variable blocks
-        // XXX: Not a fan of this, we should fix the underlying issue with variable block creation here...
         let name = hardware.get_mangled_variable_name();
-        if find_mangled_variable(unit, &name) {
-            return None; // Already exists, skip
+        variable.initializer = Some(AstFactory::create_member_reference(
+            AstFactory::create_identifier(
+                &name,
+                SourceLocation::internal(),
+                self.id_provider.next_id(),
+            ),
+            None,
+            self.id_provider.next_id(),
+        ));
+
+        if self.known_hw_globals.insert(name.clone()) {
+            self.mangled_globals.push(Variable {
+                name,
+                data_type_declaration: ref_ty.unwrap_or(variable.data_type_declaration.clone()),
+                initializer: None,
+                address: None,
+                location: node.location.clone(),
+            });
         }
+    }
 
-        Some(Variable {
-            name,
-            data_type_declaration: data_type.get_inner_pointer_ty().unwrap_or(data_type.clone()),
-            initializer: None,
-            address: None,
-            location: address.get_location(),
-        })
-    });
+    fn visit_user_type_declaration(&mut self, user_type: &mut UserTypeDeclaration) {
+        // Set context for struct member processing
+        if let DataType::StructType { name, .. } = &user_type.data_type {
+            self.current_container = name.as_deref().unwrap_or("undefined").to_string();
+        }
+        self.current_linkage = user_type.linkage;
 
-    update_generated_globals(unit, variables.collect());
-}
+        // Walk into data_type → visit_data_type dispatches per variant
+        user_type.walk(self);
+    }
 
-fn update_generated_globals(unit: &mut CompilationUnit, mangled_globals: Vec<Variable>) {
-    let mut block = if let Some(index) = unit
-        .global_vars
-        .iter()
-        .position(|block| block.kind == VariableBlockType::Global && block.location.is_builtin_internal())
-    {
-        unit.global_vars.remove(index)
-    } else {
-        VariableBlock::default().with_block_type(VariableBlockType::Global)
-    };
-    for var in mangled_globals {
-        if !block.variables.contains(&var) {
-            block.variables.push(var);
+    fn visit_data_type(&mut self, data_type: &mut DataType) {
+        match data_type {
+            // Extract nested inline types from arrays and pointers before walking children.
+            DataType::ArrayType { name, referenced_type, .. }
+            | DataType::PointerType { name, referenced_type, .. } => {
+                self.extract_nested_type(name, referenced_type);
+            }
+
+            // Empty enum: normalize to empty expression list (no walk needed).
+            DataType::EnumType { elements, .. }
+                if matches!(elements.stmt, AstStatement::EmptyStatement { .. }) =>
+            {
+                elements.stmt = AstStatement::ExpressionList(vec![]);
+                return;
+            }
+
+            // Named non-empty enum: generate auto-incrementing initializers (no walk needed).
+            DataType::EnumType { elements, name: Some(enum_name), .. } => {
+                self.initialize_enum_elements(enum_name, elements);
+                return;
+            }
+
+            _ => {}
         }
-    }
 
-    unit.global_vars.push(block);
+        // Walk children: struct members → visit_variable, array bounds, etc.
+        data_type.walk(self);
+    }
 }
 
-fn find_mangled_variable(unit: &CompilationUnit, name: &str) -> bool {
-    unit.global_vars.iter().flat_map(|block| &block.variables).any(|var| var.name == name)
-}
+// --- Standalone helpers ---
 
 fn build_enum_initializer(
     last_name: &Option<String>,
@@ -279,62 +391,6 @@ fn build_enum_initializer(
     }
 }
 
-fn preprocess_generic_structs(pou: &mut Pou) -> Vec<UserTypeDeclaration> {
-    let mut generic_types = FxHashMap::default();
-    let mut types = vec![];
-    for binding in &pou.generics {
-        let new_name = format!("__{}__{}", pou.name, binding.name); // TODO: Naming convention (see plc_util/src/convention.rs)
-
-        //Generate a type for the generic
-        let data_type = UserTypeDeclaration {
-            data_type: DataType::GenericType {
-                name: new_name.clone(),
-                generic_symbol: binding.name.clone(),
-                nature: binding.nature,
-            },
-            initializer: None,
-            scope: Some(pou.name.clone()),
-            location: pou.location.clone(),
-            linkage: pou.linkage,
-        };
-        types.push(data_type);
-        generic_types.insert(binding.name.clone(), new_name);
-    }
-    for var in pou.variable_blocks.iter_mut().flat_map(|it| it.variables.iter_mut()) {
-        replace_generic_type_name(&mut var.data_type_declaration, &generic_types);
-    }
-    if let Some(datatype) = pou.return_type.as_mut() {
-        replace_generic_type_name(datatype, &generic_types);
-    };
-    types
-}
-
-fn preprocess_return_type(pou: &mut Pou, types: &mut Vec<UserTypeDeclaration>) {
-    let linkage = pou.linkage;
-    if let Some(return_type) = &pou.return_type {
-        if should_generate_implicit(return_type) {
-            let type_name = format!("__{}_return", &pou.name); // TODO: Naming convention (see plc_util/src/convention.rs)
-            let type_ref = DataTypeDeclaration::Reference {
-                referenced_type: type_name.clone(),
-                location: return_type.get_location(),
-            };
-            let datatype = pou.return_type.replace(type_ref);
-            if let Some(DataTypeDeclaration::Definition { mut data_type, location, scope }) = datatype {
-                data_type.set_name(type_name);
-                add_nested_datatypes(pou.name.as_str(), &mut data_type, types, &location, linkage);
-                let data_type = UserTypeDeclaration {
-                    data_type: *data_type,
-                    initializer: None,
-                    location,
-                    scope,
-                    linkage,
-                };
-                types.push(data_type);
-            }
-        }
-    }
-}
-
 fn should_generate_implicit(datatype: &DataTypeDeclaration) -> bool {
     match datatype {
         DataTypeDeclaration::Reference { .. } | DataTypeDeclaration::Aggregate { .. } => false,
@@ -347,64 +403,6 @@ fn should_generate_implicit(datatype: &DataTypeDeclaration) -> bool {
     }
 }
 
-fn should_generate_implicit_type(variable: &Variable) -> bool {
-    should_generate_implicit(&variable.data_type_declaration)
-}
-
-fn pre_process_variable_data_type(
-    container_name: &str,
-    variable: &mut Variable,
-    types: &mut Vec<UserTypeDeclaration>,
-    linkage: LinkageType,
-) {
-    let new_type_name = internal_type_name(&format!("{container_name}_"), &variable.name);
-    if let DataTypeDeclaration::Definition { mut data_type, location, scope } =
-        variable.replace_data_type_with_reference_to(new_type_name.clone())
-    {
-        // create index entry
-        add_nested_datatypes(new_type_name.as_str(), &mut data_type, types, &location, linkage);
-        data_type.set_name(new_type_name);
-        types.push(UserTypeDeclaration {
-            data_type: *data_type,
-            initializer: None,
-            location,
-            scope,
-            linkage,
-        });
-    }
-    //make sure it gets generated
-}
-
-fn add_nested_datatypes(
-    container_name: &str,
-    datatype: &mut DataType,
-    types: &mut Vec<UserTypeDeclaration>,
-    location: &SourceLocation,
-    linkage: LinkageType,
-) {
-    // TODO: Naming convention (see plc_util/src/convention.rs)
-    let new_type_name = format!("{container_name}_");
-    // FIXME: When processing pointer-to-pointer types (e.g., alias variables pointing to existing pointers),
-    // the inner type is already a DataTypeDeclaration::Reference, so replace_data_type_with_reference_to
-    // returns None and nested type processing is skipped. This results in incomplete names like "__global_alias_var_"
-    // (with trailing underscore but no suffix) when the inner pointer type should be processed.
-    // We need to distinguish between pointer references (which should be processed) and other references
-    // (which should return None) to properly handle nested pointer structures.
-    if let Some(DataTypeDeclaration::Definition { mut data_type, location: inner_location, scope }) =
-        datatype.replace_data_type_with_reference_to(new_type_name.clone(), location)
-    {
-        data_type.set_name(new_type_name.clone());
-        add_nested_datatypes(new_type_name.as_str(), &mut data_type, types, &inner_location, linkage);
-        types.push(UserTypeDeclaration {
-            data_type: *data_type,
-            initializer: None,
-            location: location.clone(),
-            scope,
-            linkage,
-        });
-    }
-}
-
 fn replace_generic_type_name(dt: &mut DataTypeDeclaration, generics: &FxHashMap<String, String>) {
     match dt {
         DataTypeDeclaration::Definition { data_type, .. } => match data_type.as_mut() {
@@ -420,6 +418,28 @@ fn replace_generic_type_name(dt: &mut DataTypeDeclaration, generics: &FxHashMap<
                 referenced_type.clone_from(type_name);
             }
         }
-        DataTypeDeclaration::Aggregate { .. } => {} //todo!(),
+        DataTypeDeclaration::Aggregate { .. } => {}
+    }
+}
+
+fn update_generated_globals(unit: &mut CompilationUnit, mangled_globals: Vec<Variable>) {
+    if mangled_globals.is_empty() {
+        return;
+    }
+    let mut block = if let Some(index) = unit
+        .global_vars
+        .iter()
+        .position(|block| block.kind == VariableBlockType::Global && block.location.is_builtin_internal())
+    {
+        unit.global_vars.remove(index)
+    } else {
+        VariableBlock::default().with_block_type(VariableBlockType::Global)
+    };
+    for var in mangled_globals {
+        if !block.variables.contains(&var) {
+            block.variables.push(var);
+        }
     }
+
+    unit.global_vars.push(block);
 }
diff --git a/compiler/plc_driver/src/tests/snapshots/plc_driver__tests__header_generator__case_2_global_complex_types_generated_header_file.snap b/compiler/plc_driver/src/tests/snapshots/plc_driver__tests__header_generator__case_2_global_complex_types_generated_header_file.snap
index 95baa4ad1cb..4216fb80988 100644
--- a/compiler/plc_driver/src/tests/snapshots/plc_driver__tests__header_generator__case_2_global_complex_types_generated_header_file.snap
+++ b/compiler/plc_driver/src/tests/snapshots/plc_driver__tests__header_generator__case_2_global_complex_types_generated_header_file.snap
@@ -22,10 +22,10 @@ extern "C" {
 
 typedef int16_t __global_gVarArrayOfArrayOfIntArray__[12];
 
-typedef __global_gVarArrayOfArrayOfIntArray__ __global_gVarArrayOfArrayOfIntArray_[12];
-
 typedef int16_t __global_gVarArrayOfIntArray_[12];
 
+typedef __global_gVarArrayOfArrayOfIntArray__ __global_gVarArrayOfArrayOfIntArray_[12];
+
 extern char gVarString[256];
 extern int16_t gVarWString[6001];
 extern int16_t gVarIntArray[12];
diff --git a/compiler/plc_driver/src/tests/snapshots/plc_driver__tests__header_generator__case_2_global_complex_types_generated_header_file_template_data.snap b/compiler/plc_driver/src/tests/snapshots/plc_driver__tests__header_generator__case_2_global_complex_types_generated_header_file_template_data.snap
index 804581facf6..bd3e0d30691 100644
--- a/compiler/plc_driver/src/tests/snapshots/plc_driver__tests__header_generator__case_2_global_complex_types_generated_header_file_template_data.snap
+++ b/compiler/plc_driver/src/tests/snapshots/plc_driver__tests__header_generator__case_2_global_complex_types_generated_header_file_template_data.snap
@@ -14,15 +14,15 @@ expression: "serde_json::to_string_pretty(&prepared_header_data).expect(\"Failed
           }
         },
         {
-          "data_type": "__global_gVarArrayOfArrayOfIntArray__",
-          "name": "__global_gVarArrayOfArrayOfIntArray_",
+          "data_type": "int16_t",
+          "name": "__global_gVarArrayOfIntArray_",
           "variable_type": {
             "Array": 12
           }
         },
         {
-          "data_type": "int16_t",
-          "name": "__global_gVarArrayOfIntArray_",
+          "data_type": "__global_gVarArrayOfArrayOfIntArray__",
+          "name": "__global_gVarArrayOfArrayOfIntArray_",
           "variable_type": {
             "Array": 12
           }
diff --git a/compiler/plc_driver/src/tests/snapshots/plc_driver__tests__header_generator__case_6_functions_with_complex_types_generated_header_file.snap b/compiler/plc_driver/src/tests/snapshots/plc_driver__tests__header_generator__case_6_functions_with_complex_types_generated_header_file.snap
index 7f3688043b0..55e945b0f92 100644
--- a/compiler/plc_driver/src/tests/snapshots/plc_driver__tests__header_generator__case_6_functions_with_complex_types_generated_header_file.snap
+++ b/compiler/plc_driver/src/tests/snapshots/plc_driver__tests__header_generator__case_6_functions_with_complex_types_generated_header_file.snap
@@ -20,10 +20,10 @@ expression: "&generated_header.get_contents()"
 extern "C" {
 #endif
 
-typedef int16_t __fnThatUsesStructWithComplexTypes_varArrayOfIntArray_[15];
-
 typedef int16_t __StructWithComplexTypes_arrayOfIntArrayField_[10];
 
+typedef int16_t __fnThatUsesStructWithComplexTypes_varArrayOfIntArray_[15];
+
 typedef int32_t ComplexEnumType;
 #define ComplexEnumType_orange ((ComplexEnumType)10)
 #define ComplexEnumType_yellow ((ComplexEnumType)20)
diff --git a/compiler/plc_driver/src/tests/snapshots/plc_driver__tests__header_generator__case_6_functions_with_complex_types_generated_header_file_template_data.snap b/compiler/plc_driver/src/tests/snapshots/plc_driver__tests__header_generator__case_6_functions_with_complex_types_generated_header_file_template_data.snap
index 4bebfa767ce..c9244b37d1e 100644
--- a/compiler/plc_driver/src/tests/snapshots/plc_driver__tests__header_generator__case_6_functions_with_complex_types_generated_header_file_template_data.snap
+++ b/compiler/plc_driver/src/tests/snapshots/plc_driver__tests__header_generator__case_6_functions_with_complex_types_generated_header_file_template_data.snap
@@ -8,16 +8,16 @@ expression: "serde_json::to_string_pretty(&prepared_header_data).expect(\"Failed
       "aliases": [
         {
           "data_type": "int16_t",
-          "name": "__fnThatUsesStructWithComplexTypes_varArrayOfIntArray_",
+          "name": "__StructWithComplexTypes_arrayOfIntArrayField_",
           "variable_type": {
-            "Array": 15
+            "Array": 10
           }
         },
         {
           "data_type": "int16_t",
-          "name": "__StructWithComplexTypes_arrayOfIntArrayField_",
+          "name": "__fnThatUsesStructWithComplexTypes_varArrayOfIntArray_",
           "variable_type": {
-            "Array": 10
+            "Array": 15
           }
         }
       ],
diff --git a/compiler/plc_lowering/src/initializer.rs b/compiler/plc_lowering/src/initializer.rs
index 3091301626b..e970cc9e13f 100644
--- a/compiler/plc_lowering/src/initializer.rs
+++ b/compiler/plc_lowering/src/initializer.rs
@@ -477,11 +477,14 @@ impl InitLoweringPolicy {
     ///
     /// Resolution order:
     /// 1) Struct literals on struct-typed fields are decomposed.
-    /// 2) Reference-typed fields use `REF=` (unwrapping `REF(...)` if present).
-    /// 3) Otherwise use direct `:=` assignment.
+    /// 2) Alias-typed fields (e.g. hardware-mapped `AT %IX...`) use `REF=`.
+    /// 3) Reference-typed fields use `REF=` (unwrapping `REF(...)` if present).
+    /// 4) Otherwise use direct `:=` assignment.
     fn for_struct_field(variable: &Variable, initializer: &AstNode, index: &Index) -> Self {
         if is_struct_type(variable, index) && initializer.is_struct_literal_initializer() {
             InitLoweringPolicy::StructDecompose
+        } else if is_alias_type(variable, index) {
+            InitLoweringPolicy::RefAssign(Box::new(initializer.clone()))
         } else if is_reference_type(variable, index) {
             let ref_rhs = extract_ref_call_argument(initializer).unwrap_or(initializer).clone();
             InitLoweringPolicy::RefAssign(Box::new(ref_rhs))
@@ -507,6 +510,22 @@ fn is_reference_type(variable: &Variable, index: &Index) -> bool {
         .is_some_and(|ti| ti.is_reference_to())
 }
 
+fn is_alias_type(variable: &Variable, index: &Index) -> bool {
+    // Check inline definition first (before pre-processing resolves the type name)
+    if let DataTypeDeclaration::Definition { data_type, .. } = &variable.data_type_declaration {
+        if let DataType::PointerType { auto_deref: Some(AutoDerefType::Alias), .. } = data_type.as_ref() {
+            return true;
+        }
+    }
+
+    // Fall back to index lookup for pre-processed types
+    variable
+        .data_type_declaration
+        .get_referenced_type()
+        .and_then(|tn| index.find_effective_type_info(tn))
+        .is_some_and(|ti| ti.is_alias())
+}
+
 /// Checks if a variable is an alias or reference variable that needs ADR() wrapping
 /// (declared with AT syntax, e.g., `px AT x : DINT`, or `REFERENCE TO ... REF= ...`)
 fn is_alias_or_reference_variable(variable: &Variable, index: &Index) -> bool {
@@ -1799,4 +1818,38 @@ mod tests {
         self.FB_INIT()
         ");
     }
+
+    #[test]
+    fn struct_member_with_hardware_address_initialized_in_constructor() {
+        let src = r#"
+        TYPE NodeB : STRUCT
+            c AT %IX1.2.3.4 : BOOL;
+        END_STRUCT
+        END_TYPE
+
+        TYPE NodeA : STRUCT
+            b : NodeB;
+        END_STRUCT
+        END_TYPE
+
+        VAR_GLOBAL
+            myNode : NodeA;
+        END_VAR
+        "#;
+
+        let initializer = parse_and_init(src);
+        // NodeB's constructor should initialize its hardware-mapped field with REF=
+        insta::assert_snapshot!(print_body_to_string(initializer.constructors.get("NodeB").unwrap()), @r"
+        intern:
+        __NodeB_c__ctor(self.c)
+        self.c REF= __PI_1_2_3_4
+        ");
+        // NodeA's constructor should call NodeB's constructor for its member
+        insta::assert_snapshot!(print_body_to_string(initializer.constructors.get("NodeA").unwrap()), @r"
+        intern:
+        NodeB__ctor(self.b)
+        ");
+        // Global constructor should call NodeA's constructor
+        insta::assert_snapshot!(print_to_string(&initializer.global_constructor), @"NodeA__ctor(myNode)");
+    }
 }
diff --git a/src/codegen/tests/address_tests.rs b/src/codegen/tests/address_tests.rs
index 5c49a2afcd4..6211e59dcca 100644
--- a/src/codegen/tests/address_tests.rs
+++ b/src/codegen/tests/address_tests.rs
@@ -127,3 +127,39 @@ fn address_used_in_body() {
     }
     "#);
 }
+
+#[test]
+fn struct_member_with_hardware_address() {
+    let res = codegen(
+        r"
+            TYPE NodeB : STRUCT
+                c AT %IX1.2.3.4 : BOOL;
+            END_STRUCT
+            END_TYPE
+
+            TYPE NodeA : STRUCT
+                b : NodeB;
+            END_STRUCT
+            END_TYPE
+
+            VAR_GLOBAL
+                myNode : NodeA;
+            END_VAR
+        ",
+    );
+
+    // The backing global __PI_1_2_3_4 is created for the hardware address.
+    // NodeB.c becomes a pointer initialized to &__PI_1_2_3_4 in NodeB__ctor (separate module).
+    filtered_assert_snapshot!(res, @r#"
+    ; ModuleID = '<internal>'
+    source_filename = "<internal>"
+    target datalayout = "[filtered]"
+    target triple = "[filtered]"
+
+    %NodeA = type { %NodeB }
+    %NodeB = type { ptr }
+
+    @myNode = global %NodeA zeroinitializer
+    @__PI_1_2_3_4 = global i8 0
+    "#);
+}
diff --git a/src/codegen/tests/debug_tests.rs b/src/codegen/tests/debug_tests.rs
index 8cc4ea73e44..2e8cba5c404 100644
--- a/src/codegen/tests/debug_tests.rs
+++ b/src/codegen/tests/debug_tests.rs
@@ -702,21 +702,21 @@ fn dbg_declare_has_valid_metadata_references_for_methods() {
       ret void, !dbg !15
     }
 
-    define void @__fb___vtable__ctor(ptr %0) {
+    define void @____vtable_fb___body__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered], !dbg !15
       store ptr %0, ptr %self, align [filtered], !dbg !15
       ret void, !dbg !15
     }
 
-    define void @____vtable_fb___body__ctor(ptr %0) {
+    define void @____vtable_fb_foo__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered], !dbg !15
       store ptr %0, ptr %self, align [filtered], !dbg !15
       ret void, !dbg !15
     }
 
-    define void @____vtable_fb_foo__ctor(ptr %0) {
+    define void @__fb___vtable__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered], !dbg !15
       store ptr %0, ptr %self, align [filtered], !dbg !15
@@ -1058,28 +1058,28 @@ END_FUNCTION
       ret void, !dbg !58
     }
 
-    define void @__main_arr__ctor(ptr %0) {
+    define void @__struct__inner_arr__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered], !dbg !58
       store ptr %0, ptr %self, align [filtered], !dbg !58
       ret void, !dbg !58
     }
 
-    define void @__struct__inner_arr__ctor(ptr %0) {
+    define void @__struct__arr__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered], !dbg !58
       store ptr %0, ptr %self, align [filtered], !dbg !58
       ret void, !dbg !58
     }
 
-    define void @__struct__arr__ctor(ptr %0) {
+    define void @__inner_arr__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered], !dbg !58
       store ptr %0, ptr %self, align [filtered], !dbg !58
       ret void, !dbg !58
     }
 
-    define void @__inner_arr__ctor(ptr %0) {
+    define void @__main_arr__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered], !dbg !58
       store ptr %0, ptr %self, align [filtered], !dbg !58
@@ -1341,28 +1341,28 @@ fn test_debug_info_regular_pointer_types() {
       ret void
     }
 
-    define void @__global_array_ptr___ctor(ptr %0) {
+    define void @__global_array_ptr__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @__global_array_ptr__ctor(ptr %0) {
+    define void @__global_struct_ptr__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @__global_struct_ptr__ctor(ptr %0) {
+    define void @__global_string_ptr__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @__global_string_ptr__ctor(ptr %0) {
+    define void @__global_array_ptr___ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
@@ -1710,35 +1710,35 @@ fn test_debug_info_mixed_pointer_types() {
       ret void, !dbg !43
     }
 
-    define void @__mixed_ptr_local_ptr__ctor(ptr %0) {
+    define void @__global_regular_ptr__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered], !dbg !43
       store ptr %0, ptr %self, align [filtered], !dbg !43
       ret void, !dbg !43
     }
 
-    define void @__mixed_ptr_local_ref__ctor(ptr %0) {
+    define void @__global_alias_var__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered], !dbg !43
       store ptr %0, ptr %self, align [filtered], !dbg !43
       ret void, !dbg !43
     }
 
-    define void @__global_regular_ptr__ctor(ptr %0) {
+    define void @__mixed_ptr_local_ptr__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered], !dbg !43
       store ptr %0, ptr %self, align [filtered], !dbg !43
       ret void, !dbg !43
     }
 
-    define void @__global_alias_var___ctor(ptr %0) {
+    define void @__mixed_ptr_local_ref__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered], !dbg !43
       store ptr %0, ptr %self, align [filtered], !dbg !43
       ret void, !dbg !43
     }
 
-    define void @__global_alias_var__ctor(ptr %0) {
+    define void @__global_alias_var___ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered], !dbg !43
       store ptr %0, ptr %self, align [filtered], !dbg !43
@@ -1882,63 +1882,63 @@ fn test_debug_info_auto_deref_reference_to_pointers() {
       ret void, !dbg !56
     }
 
-    define void @__test_with_reference_params_ref_param__ctor(ptr %0) {
+    define void @__global_basic_reference__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered], !dbg !56
       store ptr %0, ptr %self, align [filtered], !dbg !56
       ret void, !dbg !56
     }
 
-    define void @__test_with_reference_params_array_ref_param___ctor(ptr %0) {
+    define void @__global_array_reference__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered], !dbg !56
       store ptr %0, ptr %self, align [filtered], !dbg !56
       ret void, !dbg !56
     }
 
-    define void @__test_with_reference_params_array_ref_param__ctor(ptr %0) {
+    define void @__global_struct_reference__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered], !dbg !56
       store ptr %0, ptr %self, align [filtered], !dbg !56
       ret void, !dbg !56
     }
 
-    define void @__test_with_reference_params_local_reference__ctor(ptr %0) {
+    define void @__global_string_reference__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered], !dbg !56
       store ptr %0, ptr %self, align [filtered], !dbg !56
       ret void, !dbg !56
     }
 
-    define void @__global_basic_reference__ctor(ptr %0) {
+    define void @__test_with_reference_params_ref_param__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered], !dbg !56
       store ptr %0, ptr %self, align [filtered], !dbg !56
       ret void, !dbg !56
     }
 
-    define void @__global_array_reference___ctor(ptr %0) {
+    define void @__test_with_reference_params_array_ref_param__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered], !dbg !56
       store ptr %0, ptr %self, align [filtered], !dbg !56
       ret void, !dbg !56
     }
 
-    define void @__global_array_reference__ctor(ptr %0) {
+    define void @__test_with_reference_params_local_reference__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered], !dbg !56
       store ptr %0, ptr %self, align [filtered], !dbg !56
       ret void, !dbg !56
     }
 
-    define void @__global_struct_reference__ctor(ptr %0) {
+    define void @__global_array_reference___ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered], !dbg !56
       store ptr %0, ptr %self, align [filtered], !dbg !56
       ret void, !dbg !56
     }
 
-    define void @__global_string_reference__ctor(ptr %0) {
+    define void @__test_with_reference_params_array_ref_param___ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered], !dbg !56
       store ptr %0, ptr %self, align [filtered], !dbg !56
diff --git a/src/codegen/tests/initialization_test/complex_initializers.rs b/src/codegen/tests/initialization_test/complex_initializers.rs
index 9022fc9a23e..5b420656d83 100644
--- a/src/codegen/tests/initialization_test/complex_initializers.rs
+++ b/src/codegen/tests/initialization_test/complex_initializers.rs
@@ -351,14 +351,14 @@ fn init_functions_generated_for_function_blocks() {
       ret void
     }
 
-    define void @__foo___vtable__ctor(ptr %0) {
+    define void @____vtable_foo___body__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_foo___body__ctor(ptr %0) {
+    define void @__foo___vtable__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
@@ -665,42 +665,42 @@ fn nested_initializer_pous() {
       ret void
     }
 
-    define void @__foo___vtable__ctor(ptr %0) {
+    define void @____vtable_foo___body__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @__bar___vtable__ctor(ptr %0) {
+    define void @____vtable_bar___body__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @__baz___vtable__ctor(ptr %0) {
+    define void @____vtable_baz___body__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_foo___body__ctor(ptr %0) {
+    define void @__foo___vtable__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_bar___body__ctor(ptr %0) {
+    define void @__bar___vtable__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_baz___body__ctor(ptr %0) {
+    define void @__baz___vtable__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
@@ -833,14 +833,14 @@ fn local_address() {
       ret void
     }
 
-    define void @__foo___vtable__ctor(ptr %0) {
+    define void @____vtable_foo___body__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_foo___body__ctor(ptr %0) {
+    define void @__foo___vtable__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
@@ -968,21 +968,21 @@ fn user_init_called_for_variables_on_stack() {
       ret void
     }
 
-    define void @__foo___vtable__ctor(ptr %0) {
+    define void @____vtable_foo___body__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_foo___body__ctor(ptr %0) {
+    define void @____vtable_foo_FB_INIT__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_foo_FB_INIT__ctor(ptr %0) {
+    define void @__foo___vtable__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
@@ -1172,14 +1172,14 @@ fn struct_types() {
       ret void
     }
 
-    define void @__myStruct_member2___ctor(ptr %0) {
+    define void @__myStruct_member2__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @__myStruct_member2__ctor(ptr %0) {
+    define void @__myStruct_member2___ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
@@ -1358,35 +1358,35 @@ fn stateful_pous_methods_and_structs_get_init_functions() {
       ret void
     }
 
-    define void @__foo___vtable__ctor(ptr %0) {
+    define void @____vtable_foo___body__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @__cl___vtable__ctor(ptr %0) {
+    define void @____vtable_foo_m__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_foo___body__ctor(ptr %0) {
+    define void @____vtable_cl_m__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_foo_m__ctor(ptr %0) {
+    define void @__foo___vtable__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_cl_m__ctor(ptr %0) {
+    define void @__cl___vtable__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
@@ -1513,14 +1513,14 @@ fn global_instance() {
       ret void
     }
 
-    define void @__foo___vtable__ctor(ptr %0) {
+    define void @____vtable_foo___body__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_foo___body__ctor(ptr %0) {
+    define void @__foo___vtable__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
@@ -1657,14 +1657,14 @@ fn aliased_types() {
       ret void
     }
 
-    define void @__foo___vtable__ctor(ptr %0) {
+    define void @____vtable_foo___body__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_foo___body__ctor(ptr %0) {
+    define void @__foo___vtable__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
@@ -1858,14 +1858,14 @@ fn var_config_aliased_variables_initialized() {
       ret void
     }
 
-    define void @__FB___vtable__ctor(ptr %0) {
+    define void @____vtable_FB___body__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_FB___body__ctor(ptr %0) {
+    define void @__FB___vtable__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
@@ -1969,14 +1969,14 @@ fn var_external_blocks_are_ignored_in_init_functions() {
       ret void
     }
 
-    define void @__foo___vtable__ctor(ptr %0) {
+    define void @____vtable_foo___body__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_foo___body__ctor(ptr %0) {
+    define void @__foo___vtable__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
@@ -2109,14 +2109,14 @@ fn ref_to_local_member() {
       ret void
     }
 
-    define void @__foo___vtable__ctor(ptr %0) {
+    define void @____vtable_foo___body__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_foo___body__ctor(ptr %0) {
+    define void @__foo___vtable__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
@@ -2251,14 +2251,14 @@ fn ref_to_local_member_shadows_global() {
       ret void
     }
 
-    define void @__foo___vtable__ctor(ptr %0) {
+    define void @____vtable_foo___body__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_foo___body__ctor(ptr %0) {
+    define void @__foo___vtable__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
@@ -2375,14 +2375,14 @@ fn temporary_variable_ref_to_local_member() {
       ret void
     }
 
-    define void @__foo___vtable__ctor(ptr %0) {
+    define void @____vtable_foo___body__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_foo___body__ctor(ptr %0) {
+    define void @__foo___vtable__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
@@ -2565,21 +2565,21 @@ fn initializing_method_variables_with_refs() {
       ret void
     }
 
-    define void @__foo___vtable__ctor(ptr %0) {
+    define void @____vtable_foo___body__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_foo___body__ctor(ptr %0) {
+    define void @____vtable_foo_bar__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_foo_bar__ctor(ptr %0) {
+    define void @__foo___vtable__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
@@ -2691,21 +2691,21 @@ fn initializing_method_variables_with_refs_referencing_parent_pou_variable() {
       ret void
     }
 
-    define void @__foo___vtable__ctor(ptr %0) {
+    define void @____vtable_foo___body__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_foo___body__ctor(ptr %0) {
+    define void @____vtable_foo_bar__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_foo_bar__ctor(ptr %0) {
+    define void @__foo___vtable__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
@@ -2813,21 +2813,21 @@ fn initializing_method_variables_with_refs_referencing_global_variable() {
       ret void
     }
 
-    define void @__foo___vtable__ctor(ptr %0) {
+    define void @____vtable_foo___body__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_foo___body__ctor(ptr %0) {
+    define void @____vtable_foo_bar__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_foo_bar__ctor(ptr %0) {
+    define void @__foo___vtable__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
@@ -2938,21 +2938,21 @@ fn initializing_method_variables_with_refs_shadowing() {
       ret void
     }
 
-    define void @__foo___vtable__ctor(ptr %0) {
+    define void @____vtable_foo___body__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_foo___body__ctor(ptr %0) {
+    define void @____vtable_foo_bar__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_foo_bar__ctor(ptr %0) {
+    define void @__foo___vtable__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
@@ -3059,21 +3059,21 @@ fn initializing_method_variables_with_alias() {
       ret void
     }
 
-    define void @__foo___vtable__ctor(ptr %0) {
+    define void @____vtable_foo___body__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_foo___body__ctor(ptr %0) {
+    define void @____vtable_foo_bar__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_foo_bar__ctor(ptr %0) {
+    define void @__foo___vtable__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
@@ -3180,21 +3180,21 @@ fn initializing_method_variables_with_reference_to() {
       ret void
     }
 
-    define void @__foo___vtable__ctor(ptr %0) {
+    define void @____vtable_foo___body__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_foo___body__ctor(ptr %0) {
+    define void @____vtable_foo_bar__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_foo_bar__ctor(ptr %0) {
+    define void @__foo___vtable__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
@@ -3352,35 +3352,35 @@ fn methods_call_init_functions_for_their_members() {
       ret void
     }
 
-    define void @__foo___vtable__ctor(ptr %0) {
+    define void @____vtable_foo___body__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @__bar___vtable__ctor(ptr %0) {
+    define void @____vtable_bar___body__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_foo___body__ctor(ptr %0) {
+    define void @____vtable_bar_baz__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_bar___body__ctor(ptr %0) {
+    define void @__foo___vtable__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_bar_baz__ctor(ptr %0) {
+    define void @__bar___vtable__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
@@ -3522,21 +3522,21 @@ fn user_fb_init_is_added_and_called_if_it_exists() {
       ret void
     }
 
-    define void @__foo___vtable__ctor(ptr %0) {
+    define void @____vtable_foo___body__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_foo___body__ctor(ptr %0) {
+    define void @____vtable_foo_FB_INIT__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_foo_FB_INIT__ctor(ptr %0) {
+    define void @__foo___vtable__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
@@ -3696,21 +3696,21 @@ fn user_fb_init_in_global_struct() {
       ret void
     }
 
-    define void @__foo___vtable__ctor(ptr %0) {
+    define void @____vtable_foo___body__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_foo___body__ctor(ptr %0) {
+    define void @____vtable_foo_FB_INIT__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_foo_FB_INIT__ctor(ptr %0) {
+    define void @__foo___vtable__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
@@ -3793,12 +3793,12 @@ fn user_init_called_when_declared_as_external() {
 
     declare void @__vtable_foo__ctor(ptr)
 
-    declare void @__foo___vtable__ctor(ptr)
-
     declare void @____vtable_foo___body__ctor(ptr)
 
     declare void @____vtable_foo_FB_INIT__ctor(ptr)
 
+    declare void @__foo___vtable__ctor(ptr)
+
     define void @__unit___internal____ctor() {
     entry:
       call void @prog__ctor(ptr @prog_instance)
@@ -3907,14 +3907,14 @@ fn constructors_only_emits_only_ctor_definitions() {
       ret void
     }
 
-    define void @__MyFB___vtable__ctor(ptr %0) {
+    define void @____vtable_MyFB___body__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_MyFB___body__ctor(ptr %0) {
+    define void @__MyFB___vtable__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
diff --git a/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__type_initializers__enums_with_inline_initializer_are_initialized.snap b/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__type_initializers__enums_with_inline_initializer_are_initialized.snap
index 454561342d0..a961a7428a3 100644
--- a/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__type_initializers__enums_with_inline_initializer_are_initialized.snap
+++ b/src/codegen/tests/initialization_test/snapshots/rusty__codegen__tests__initialization_test__type_initializers__enums_with_inline_initializer_are_initialized.snap
@@ -11,6 +11,8 @@ target triple = "[filtered]"
 @__main_var1.x1 = unnamed_addr constant i32 1
 @__main_var2.x7 = unnamed_addr constant i32 2
 @__global_x.yellow = unnamed_addr constant i32 1
+@__global_x.red = unnamed_addr constant i32 0
+@__global_x.green = unnamed_addr constant i32 2
 @__main_y.redy = unnamed_addr constant i32 1
 @__main_y.yellowy = unnamed_addr constant i32 2
 @__main_y.greeny = unnamed_addr constant i32 3
@@ -20,8 +22,6 @@ target triple = "[filtered]"
 @__main_var2.x6 = unnamed_addr constant i32 1
 @__main_var3.x8 = unnamed_addr constant i32 0
 @__main_var3.x9 = unnamed_addr constant i32 1
-@__global_x.red = unnamed_addr constant i32 0
-@__global_x.green = unnamed_addr constant i32 2
 
 define i32 @main() {
 entry:
diff --git a/src/codegen/tests/oop_tests.rs b/src/codegen/tests/oop_tests.rs
index ed4178b4d3a..e6728dee90c 100644
--- a/src/codegen/tests/oop_tests.rs
+++ b/src/codegen/tests/oop_tests.rs
@@ -119,21 +119,21 @@ fn members_from_base_class_are_available_in_subclasses() {
       ret void
     }
 
-    define void @__foo___vtable__ctor(ptr %0) {
+    define void @____vtable_foo___body__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_foo___body__ctor(ptr %0) {
+    define void @____vtable_bar___body__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_bar___body__ctor(ptr %0) {
+    define void @__foo___vtable__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
@@ -305,35 +305,35 @@ fn write_to_parent_variable_qualified_access() {
       ret void
     }
 
-    define void @__fb___vtable__ctor(ptr %0) {
+    define void @____vtable_fb___body__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @__foo___vtable__ctor(ptr %0) {
+    define void @____vtable_fb2___body__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_fb___body__ctor(ptr %0) {
+    define void @____vtable_foo___body__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_fb2___body__ctor(ptr %0) {
+    define void @__fb___vtable__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_foo___body__ctor(ptr %0) {
+    define void @__foo___vtable__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
@@ -504,35 +504,35 @@ fn write_to_parent_variable_in_instance() {
       ret void
     }
 
-    define void @__foo___vtable__ctor(ptr %0) {
+    define void @____vtable_foo___body__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_foo___body__ctor(ptr %0) {
+    define void @____vtable_foo_baz__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_foo_baz__ctor(ptr %0) {
+    define void @____vtable_bar___body__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_bar___body__ctor(ptr %0) {
+    define void @____vtable_bar_baz__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_bar_baz__ctor(ptr %0) {
+    define void @__foo___vtable__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
@@ -796,28 +796,28 @@ fn array_in_parent_generated() {
       ret void
     }
 
-    define void @__grandparent___vtable__ctor(ptr %0) {
+    define void @____vtable_grandparent___body__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_grandparent___body__ctor(ptr %0) {
+    define void @____vtable_parent___body__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_parent___body__ctor(ptr %0) {
+    define void @____vtable_child___body__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_child___body__ctor(ptr %0) {
+    define void @__grandparent___vtable__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
@@ -1054,28 +1054,28 @@ fn complex_array_access_generated() {
       ret void
     }
 
-    define void @__grandparent___vtable__ctor(ptr %0) {
+    define void @____vtable_grandparent___body__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_grandparent___body__ctor(ptr %0) {
+    define void @____vtable_parent___body__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_parent___body__ctor(ptr %0) {
+    define void @____vtable_child___body__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_child___body__ctor(ptr %0) {
+    define void @__grandparent___vtable__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
@@ -1233,28 +1233,28 @@ fn this_in_method_call_chain() {
       ret void
     }
 
-    define void @__FB_Test___vtable__ctor(ptr %0) {
+    define void @____vtable_FB_Test___body__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_FB_Test___body__ctor(ptr %0) {
+    define void @____vtable_FB_Test_Step__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_FB_Test_Step__ctor(ptr %0) {
+    define void @____vtable_FB_Test_Increment__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_FB_Test_Increment__ctor(ptr %0) {
+    define void @__FB_Test___vtable__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
@@ -1366,21 +1366,21 @@ fn this_in_method_and_body_in_function_block() {
       ret void
     }
 
-    define void @__FB_Test___vtable__ctor(ptr %0) {
+    define void @____vtable_FB_Test___body__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_FB_Test___body__ctor(ptr %0) {
+    define void @____vtable_FB_Test_GetVal__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_FB_Test_GetVal__ctor(ptr %0) {
+    define void @__FB_Test___vtable__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
@@ -1562,42 +1562,42 @@ fn pass_this_to_method() {
       ret void
     }
 
-    define void @__FB_Test___vtable__ctor(ptr %0) {
+    define void @____vtable_FB_Test___body__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @__FB_Test2___vtable__ctor(ptr %0) {
+    define void @____vtable_FB_Test_foo__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_FB_Test___body__ctor(ptr %0) {
+    define void @____vtable_FB_Test2___body__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_FB_Test_foo__ctor(ptr %0) {
+    define void @____vtable_FB_Test2_bar__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_FB_Test2___body__ctor(ptr %0) {
+    define void @__FB_Test___vtable__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_FB_Test2_bar__ctor(ptr %0) {
+    define void @__FB_Test2___vtable__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
@@ -1716,21 +1716,21 @@ fn this_with_shadowed_variable() {
       ret void
     }
 
-    define void @__FB_Test___vtable__ctor(ptr %0) {
+    define void @____vtable_FB_Test___body__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_FB_Test___body__ctor(ptr %0) {
+    define void @____vtable_FB_Test_shadow_val__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_FB_Test_shadow_val__ctor(ptr %0) {
+    define void @__FB_Test___vtable__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
@@ -1833,14 +1833,14 @@ fn this_calling_function_and_passing_this() {
       ret void
     }
 
-    define void @__FB_Test___vtable__ctor(ptr %0) {
+    define void @____vtable_FB_Test___body__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_FB_Test___body__ctor(ptr %0) {
+    define void @__FB_Test___vtable__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
@@ -1997,35 +1997,35 @@ fn this_in_property_and_calling_method() {
       ret void
     }
 
-    define void @__FB_Test___vtable__ctor(ptr %0) {
+    define void @____vtable_FB_Test___body__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_FB_Test___body__ctor(ptr %0) {
+    define void @____vtable_FB_Test_DoubleX__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_FB_Test_DoubleX__ctor(ptr %0) {
+    define void @____vtable_FB_Test___get_Value__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_FB_Test___get_Value__ctor(ptr %0) {
+    define void @____vtable_FB_Test___set_Value__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_FB_Test___set_Value__ctor(ptr %0) {
+    define void @__FB_Test___vtable__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
@@ -2135,21 +2135,21 @@ fn this_with_self_pointer() {
       ret void
     }
 
-    define void @__FB_Test___vtable__ctor(ptr %0) {
+    define void @____vtable_FB_Test___body__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_FB_Test___body__ctor(ptr %0) {
+    define void @____vtable_FB_Test_InitRef__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_FB_Test_InitRef__ctor(ptr %0) {
+    define void @__FB_Test___vtable__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
@@ -2241,14 +2241,14 @@ fn this_in_variable_initialization() {
       ret void
     }
 
-    define void @__FB___vtable__ctor(ptr %0) {
+    define void @____vtable_FB___body__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_FB___body__ctor(ptr %0) {
+    define void @__FB___vtable__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
@@ -2321,14 +2321,14 @@ fn this_in_action_in_functionblock() {
       ret void
     }
 
-    define void @__fb___vtable__ctor(ptr %0) {
+    define void @____vtable_fb___body__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_fb___body__ctor(ptr %0) {
+    define void @__fb___vtable__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
@@ -2429,21 +2429,21 @@ fn this_calling_functionblock_body_from_method() {
       ret void
     }
 
-    define void @__fb___vtable__ctor(ptr %0) {
+    define void @____vtable_fb___body__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_fb___body__ctor(ptr %0) {
+    define void @____vtable_fb_foo__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_fb_foo__ctor(ptr %0) {
+    define void @__fb___vtable__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
@@ -2606,35 +2606,35 @@ fn fb_extension_with_output() {
       ret void
     }
 
-    define void @__foo___vtable__ctor(ptr %0) {
+    define void @____vtable_foo___body__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_foo___body__ctor(ptr %0) {
+    define void @____vtable_foo_met1__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_foo_met1__ctor(ptr %0) {
+    define void @____vtable_foo2___body__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_foo2___body__ctor(ptr %0) {
+    define void @____vtable_foo2_met1__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_foo2_met1__ctor(ptr %0) {
+    define void @__foo___vtable__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
@@ -2830,35 +2830,35 @@ fn function_with_output_used_in_main_by_extension() {
       ret void
     }
 
-    define void @__foo___vtable__ctor(ptr %0) {
+    define void @____vtable_foo___body__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_foo___body__ctor(ptr %0) {
+    define void @____vtable_foo_met1__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_foo_met1__ctor(ptr %0) {
+    define void @____vtable_foo2___body__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_foo2___body__ctor(ptr %0) {
+    define void @____vtable_foo2_met1__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_foo2_met1__ctor(ptr %0) {
+    define void @__foo___vtable__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
diff --git a/src/codegen/tests/oop_tests/debug_tests.rs b/src/codegen/tests/oop_tests/debug_tests.rs
index eb3c2442871..aacd2805a3d 100644
--- a/src/codegen/tests/oop_tests/debug_tests.rs
+++ b/src/codegen/tests/oop_tests/debug_tests.rs
@@ -119,21 +119,21 @@ fn members_from_base_class_are_available_in_subclasses() {
       ret void, !dbg !35
     }
 
-    define void @__foo___vtable__ctor(ptr %0) {
+    define void @____vtable_foo___body__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered], !dbg !35
       store ptr %0, ptr %self, align [filtered], !dbg !35
       ret void, !dbg !35
     }
 
-    define void @____vtable_foo___body__ctor(ptr %0) {
+    define void @____vtable_bar___body__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered], !dbg !35
       store ptr %0, ptr %self, align [filtered], !dbg !35
       ret void, !dbg !35
     }
 
-    define void @____vtable_bar___body__ctor(ptr %0) {
+    define void @__foo___vtable__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered], !dbg !35
       store ptr %0, ptr %self, align [filtered], !dbg !35
@@ -348,35 +348,35 @@ fn write_to_parent_variable_qualified_access() {
       ret void, !dbg !38
     }
 
-    define void @__fb___vtable__ctor(ptr %0) {
+    define void @____vtable_fb___body__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered], !dbg !38
       store ptr %0, ptr %self, align [filtered], !dbg !38
       ret void, !dbg !38
     }
 
-    define void @__foo___vtable__ctor(ptr %0) {
+    define void @____vtable_fb2___body__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered], !dbg !38
       store ptr %0, ptr %self, align [filtered], !dbg !38
       ret void, !dbg !38
     }
 
-    define void @____vtable_fb___body__ctor(ptr %0) {
+    define void @____vtable_foo___body__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered], !dbg !38
       store ptr %0, ptr %self, align [filtered], !dbg !38
       ret void, !dbg !38
     }
 
-    define void @____vtable_fb2___body__ctor(ptr %0) {
+    define void @__fb___vtable__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered], !dbg !38
       store ptr %0, ptr %self, align [filtered], !dbg !38
       ret void, !dbg !38
     }
 
-    define void @____vtable_foo___body__ctor(ptr %0) {
+    define void @__foo___vtable__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered], !dbg !38
       store ptr %0, ptr %self, align [filtered], !dbg !38
@@ -595,35 +595,35 @@ fn write_to_parent_variable_in_instance() {
       ret void, !dbg !45
     }
 
-    define void @__foo___vtable__ctor(ptr %0) {
+    define void @____vtable_foo___body__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered], !dbg !45
       store ptr %0, ptr %self, align [filtered], !dbg !45
       ret void, !dbg !45
     }
 
-    define void @____vtable_foo___body__ctor(ptr %0) {
+    define void @____vtable_foo_baz__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered], !dbg !45
       store ptr %0, ptr %self, align [filtered], !dbg !45
       ret void, !dbg !45
     }
 
-    define void @____vtable_foo_baz__ctor(ptr %0) {
+    define void @____vtable_bar___body__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered], !dbg !45
       store ptr %0, ptr %self, align [filtered], !dbg !45
       ret void, !dbg !45
     }
 
-    define void @____vtable_bar___body__ctor(ptr %0) {
+    define void @____vtable_bar_baz__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered], !dbg !45
       store ptr %0, ptr %self, align [filtered], !dbg !45
       ret void, !dbg !45
     }
 
-    define void @____vtable_bar_baz__ctor(ptr %0) {
+    define void @__foo___vtable__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered], !dbg !45
       store ptr %0, ptr %self, align [filtered], !dbg !45
@@ -941,28 +941,28 @@ fn array_in_parent_generated() {
       ret void, !dbg !56
     }
 
-    define void @__grandparent___vtable__ctor(ptr %0) {
+    define void @____vtable_grandparent___body__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered], !dbg !56
       store ptr %0, ptr %self, align [filtered], !dbg !56
       ret void, !dbg !56
     }
 
-    define void @____vtable_grandparent___body__ctor(ptr %0) {
+    define void @____vtable_parent___body__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered], !dbg !56
       store ptr %0, ptr %self, align [filtered], !dbg !56
       ret void, !dbg !56
     }
 
-    define void @____vtable_parent___body__ctor(ptr %0) {
+    define void @____vtable_child___body__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered], !dbg !56
       store ptr %0, ptr %self, align [filtered], !dbg !56
       ret void, !dbg !56
     }
 
-    define void @____vtable_child___body__ctor(ptr %0) {
+    define void @__grandparent___vtable__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered], !dbg !56
       store ptr %0, ptr %self, align [filtered], !dbg !56
@@ -1263,28 +1263,28 @@ fn complex_array_access_generated() {
       ret void, !dbg !44
     }
 
-    define void @__grandparent___vtable__ctor(ptr %0) {
+    define void @____vtable_grandparent___body__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered], !dbg !44
       store ptr %0, ptr %self, align [filtered], !dbg !44
       ret void, !dbg !44
     }
 
-    define void @____vtable_grandparent___body__ctor(ptr %0) {
+    define void @____vtable_parent___body__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered], !dbg !44
       store ptr %0, ptr %self, align [filtered], !dbg !44
       ret void, !dbg !44
     }
 
-    define void @____vtable_parent___body__ctor(ptr %0) {
+    define void @____vtable_child___body__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered], !dbg !44
       store ptr %0, ptr %self, align [filtered], !dbg !44
       ret void, !dbg !44
     }
 
-    define void @____vtable_child___body__ctor(ptr %0) {
+    define void @__grandparent___vtable__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered], !dbg !44
       store ptr %0, ptr %self, align [filtered], !dbg !44
@@ -1473,35 +1473,35 @@ fn function_block_method_debug_info() {
       ret void, !dbg !26
     }
 
-    define void @__foo___vtable__ctor(ptr %0) {
+    define void @____vtable_foo___body__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered], !dbg !26
       store ptr %0, ptr %self, align [filtered], !dbg !26
       ret void, !dbg !26
     }
 
-    define void @____vtable_foo___body__ctor(ptr %0) {
+    define void @____vtable_foo_baz__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered], !dbg !26
       store ptr %0, ptr %self, align [filtered], !dbg !26
       ret void, !dbg !26
     }
 
-    define void @____vtable_foo_baz__ctor(ptr %0) {
+    define void @____vtable_bar___body__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered], !dbg !26
       store ptr %0, ptr %self, align [filtered], !dbg !26
       ret void, !dbg !26
     }
 
-    define void @____vtable_bar___body__ctor(ptr %0) {
+    define void @____vtable_bar_baz__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered], !dbg !26
       store ptr %0, ptr %self, align [filtered], !dbg !26
       ret void, !dbg !26
     }
 
-    define void @____vtable_bar_baz__ctor(ptr %0) {
+    define void @__foo___vtable__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered], !dbg !26
       store ptr %0, ptr %self, align [filtered], !dbg !26
@@ -1881,28 +1881,28 @@ END_FUNCTION
       ret void, !dbg !83
     }
 
-    define void @__parent___vtable__ctor(ptr %0) {
+    define void @____vtable_parent___body__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered], !dbg !83
       store ptr %0, ptr %self, align [filtered], !dbg !83
       ret void, !dbg !83
     }
 
-    define void @____vtable_parent___body__ctor(ptr %0) {
+    define void @____vtable_child___body__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered], !dbg !83
       store ptr %0, ptr %self, align [filtered], !dbg !83
       ret void, !dbg !83
     }
 
-    define void @____vtable_child___body__ctor(ptr %0) {
+    define void @____vtable_grandchild___body__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered], !dbg !83
       store ptr %0, ptr %self, align [filtered], !dbg !83
       ret void, !dbg !83
     }
 
-    define void @____vtable_grandchild___body__ctor(ptr %0) {
+    define void @__parent___vtable__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered], !dbg !83
       store ptr %0, ptr %self, align [filtered], !dbg !83
diff --git a/src/codegen/tests/oop_tests/super_tests.rs b/src/codegen/tests/oop_tests/super_tests.rs
index 995fdadb5a3..03b02a55062 100644
--- a/src/codegen/tests/oop_tests/super_tests.rs
+++ b/src/codegen/tests/oop_tests/super_tests.rs
@@ -110,21 +110,21 @@ fn super_keyword_basic_access() {
       ret void
     }
 
-    define void @__parent___vtable__ctor(ptr %0) {
+    define void @____vtable_parent___body__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_parent___body__ctor(ptr %0) {
+    define void @____vtable_child___body__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_child___body__ctor(ptr %0) {
+    define void @__parent___vtable__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
@@ -262,21 +262,21 @@ fn super_without_deref() {
       ret void
     }
 
-    define void @__parent___vtable__ctor(ptr %0) {
+    define void @____vtable_parent___body__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_parent___body__ctor(ptr %0) {
+    define void @____vtable_child___body__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_child___body__ctor(ptr %0) {
+    define void @__parent___vtable__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
@@ -474,42 +474,42 @@ fn super_in_method_calls() {
       ret void
     }
 
-    define void @__parent___vtable__ctor(ptr %0) {
+    define void @____vtable_parent___body__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_parent___body__ctor(ptr %0) {
+    define void @____vtable_parent_process__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_parent_process__ctor(ptr %0) {
+    define void @____vtable_child___body__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_child___body__ctor(ptr %0) {
+    define void @____vtable_child_process__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_child_process__ctor(ptr %0) {
+    define void @____vtable_child_test__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_child_test__ctor(ptr %0) {
+    define void @__parent___vtable__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
@@ -654,21 +654,21 @@ fn super_in_complex_expressions() {
       ret void
     }
 
-    define void @__parent___vtable__ctor(ptr %0) {
+    define void @____vtable_parent___body__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_parent___body__ctor(ptr %0) {
+    define void @____vtable_child___body__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_child___body__ctor(ptr %0) {
+    define void @__parent___vtable__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
@@ -816,21 +816,21 @@ fn super_with_array_access() {
       ret void
     }
 
-    define void @__parent___vtable__ctor(ptr %0) {
+    define void @____vtable_parent___body__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_parent___body__ctor(ptr %0) {
+    define void @____vtable_child___body__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_child___body__ctor(ptr %0) {
+    define void @__parent___vtable__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
@@ -1106,13 +1106,6 @@ fn super_in_multi_level_inheritance() {
       ret void
     }
 
-    define void @__grandparent___vtable__ctor(ptr %0) {
-    entry:
-      %self = alloca ptr, align [filtered]
-      store ptr %0, ptr %self, align [filtered]
-      ret void
-    }
-
     define void @____vtable_grandparent___body__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
@@ -1176,6 +1169,13 @@ fn super_in_multi_level_inheritance() {
       ret void
     }
 
+    define void @__grandparent___vtable__ctor(ptr %0) {
+    entry:
+      %self = alloca ptr, align [filtered]
+      store ptr %0, ptr %self, align [filtered]
+      ret void
+    }
+
     define void @__unit___internal____ctor() {
     entry:
       call void @__vtable_grandparent__ctor(ptr @__vtable_grandparent_instance)
@@ -1318,21 +1318,21 @@ fn super_with_pointer_operations() {
       ret void
     }
 
-    define void @__parent___vtable__ctor(ptr %0) {
+    define void @____vtable_parent___body__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_parent___body__ctor(ptr %0) {
+    define void @____vtable_child___body__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_child___body__ctor(ptr %0) {
+    define void @__parent___vtable__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
@@ -1529,28 +1529,28 @@ fn super_in_conditionals() {
       ret void
     }
 
-    define void @__parent___vtable__ctor(ptr %0) {
+    define void @____vtable_parent___body__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_parent___body__ctor(ptr %0) {
+    define void @____vtable_child___body__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_child___body__ctor(ptr %0) {
+    define void @____vtable_child_test__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_child_test__ctor(ptr %0) {
+    define void @__parent___vtable__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
@@ -1679,21 +1679,21 @@ fn super_with_const_variables() {
       ret void
     }
 
-    define void @__parent___vtable__ctor(ptr %0) {
+    define void @____vtable_parent___body__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_parent___body__ctor(ptr %0) {
+    define void @____vtable_child___body__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_child___body__ctor(ptr %0) {
+    define void @__parent___vtable__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
@@ -1881,28 +1881,28 @@ fn super_as_function_parameter() {
       ret void
     }
 
-    define void @__parent___vtable__ctor(ptr %0) {
+    define void @____vtable_parent___body__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_parent___body__ctor(ptr %0) {
+    define void @____vtable_child___body__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_child___body__ctor(ptr %0) {
+    define void @____vtable_child_test__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_child_test__ctor(ptr %0) {
+    define void @__parent___vtable__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
@@ -2120,42 +2120,42 @@ fn super_with_deeply_nested_expressions() {
       ret void
     }
 
-    define void @__parent___vtable__ctor(ptr %0) {
+    define void @____vtable_parent___body__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_parent___body__ctor(ptr %0) {
+    define void @____vtable_parent_calc__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_parent_calc__ctor(ptr %0) {
+    define void @____vtable_child___body__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_child___body__ctor(ptr %0) {
+    define void @____vtable_child_calc__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_child_calc__ctor(ptr %0) {
+    define void @____vtable_child_test__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_child_test__ctor(ptr %0) {
+    define void @__parent___vtable__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
@@ -2463,42 +2463,42 @@ fn super_in_loop_constructs() {
       ret void
     }
 
-    define void @__parent___vtable__ctor(ptr %0) {
+    define void @____vtable_parent___body__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_parent___body__ctor(ptr %0) {
+    define void @____vtable_parent_increment__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_parent_increment__ctor(ptr %0) {
+    define void @____vtable_child___body__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_child___body__ctor(ptr %0) {
+    define void @____vtable_child_increment__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_child_increment__ctor(ptr %0) {
+    define void @____vtable_child_process__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_child_process__ctor(ptr %0) {
+    define void @__parent___vtable__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
@@ -2730,13 +2730,6 @@ fn super_with_method_overrides_in_three_levels() {
       ret void
     }
 
-    define void @__grandparent___vtable__ctor(ptr %0) {
-    entry:
-      %self = alloca ptr, align [filtered]
-      store ptr %0, ptr %self, align [filtered]
-      ret void
-    }
-
     define void @____vtable_grandparent___body__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
@@ -2779,6 +2772,13 @@ fn super_with_method_overrides_in_three_levels() {
       ret void
     }
 
+    define void @__grandparent___vtable__ctor(ptr %0) {
+    entry:
+      %self = alloca ptr, align [filtered]
+      store ptr %0, ptr %self, align [filtered]
+      ret void
+    }
+
     define void @__unit___internal____ctor() {
     entry:
       call void @__vtable_grandparent__ctor(ptr @__vtable_grandparent_instance)
@@ -3042,28 +3042,28 @@ fn super_with_structured_types() {
       ret void
     }
 
-    define void @__parent___vtable__ctor(ptr %0) {
+    define void @____vtable_parent___body__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_parent___body__ctor(ptr %0) {
+    define void @____vtable_child___body__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_child___body__ctor(ptr %0) {
+    define void @____vtable_child_test__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_child_test__ctor(ptr %0) {
+    define void @__parent___vtable__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
@@ -3225,35 +3225,35 @@ fn super_in_action_blocks() {
       ret void
     }
 
-    define void @__parent___vtable__ctor(ptr %0) {
+    define void @____vtable_parent___body__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_parent___body__ctor(ptr %0) {
+    define void @____vtable_parent_increment__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_parent_increment__ctor(ptr %0) {
+    define void @____vtable_child___body__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_child___body__ctor(ptr %0) {
+    define void @____vtable_child_increment__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_child_increment__ctor(ptr %0) {
+    define void @__parent___vtable__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
diff --git a/src/codegen/tests/polymorphism.rs b/src/codegen/tests/polymorphism.rs
index 0793fe84ace..c0e07996d68 100644
--- a/src/codegen/tests/polymorphism.rs
+++ b/src/codegen/tests/polymorphism.rs
@@ -215,35 +215,35 @@ fn simple_overridden_method() {
       ret void
     }
 
-    define void @__A___vtable__ctor(ptr %0) {
+    define void @____vtable_A___body__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_A___body__ctor(ptr %0) {
+    define void @____vtable_A_foo__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_A_foo__ctor(ptr %0) {
+    define void @____vtable_B___body__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_B___body__ctor(ptr %0) {
+    define void @____vtable_B_foo__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_B_foo__ctor(ptr %0) {
+    define void @__A___vtable__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
@@ -370,28 +370,28 @@ fn method_call_within_method() {
       ret void
     }
 
-    define void @__A___vtable__ctor(ptr %0) {
+    define void @____vtable_A___body__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_A___body__ctor(ptr %0) {
+    define void @____vtable_A_foo__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_A_foo__ctor(ptr %0) {
+    define void @____vtable_A_bar__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_A_bar__ctor(ptr %0) {
+    define void @__A___vtable__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
@@ -666,13 +666,6 @@ fn this_is_untouched() {
       ret void
     }
 
-    define void @__A___vtable__ctor(ptr %0) {
-    entry:
-      %self = alloca ptr, align [filtered]
-      store ptr %0, ptr %self, align [filtered]
-      ret void
-    }
-
     define void @____vtable_A___body__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
@@ -736,6 +729,13 @@ fn this_is_untouched() {
       ret void
     }
 
+    define void @__A___vtable__ctor(ptr %0) {
+    entry:
+      %self = alloca ptr, align [filtered]
+      store ptr %0, ptr %self, align [filtered]
+      ret void
+    }
+
     define void @__unit___internal____ctor() {
     entry:
       call void @__vtable_A__ctor(ptr @__vtable_A_instance)
@@ -937,13 +937,6 @@ fn super_is_untouched() {
       ret void
     }
 
-    define void @__A___vtable__ctor(ptr %0) {
-    entry:
-      %self = alloca ptr, align [filtered]
-      store ptr %0, ptr %self, align [filtered]
-      ret void
-    }
-
     define void @____vtable_A___body__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
@@ -986,6 +979,13 @@ fn super_is_untouched() {
       ret void
     }
 
+    define void @__A___vtable__ctor(ptr %0) {
+    entry:
+      %self = alloca ptr, align [filtered]
+      store ptr %0, ptr %self, align [filtered]
+      ret void
+    }
+
     define void @__unit___internal____ctor() {
     entry:
       call void @__vtable_A__ctor(ptr @__vtable_A_instance)
diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__debug_tests__global_var_array_added_to_debug_info.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__debug_tests__global_var_array_added_to_debug_info.snap
index bd144e1e9b9..ca9b1d6fe86 100644
--- a/src/codegen/tests/snapshots/rusty__codegen__tests__debug_tests__global_var_array_added_to_debug_info.snap
+++ b/src/codegen/tests/snapshots/rusty__codegen__tests__debug_tests__global_var_array_added_to_debug_info.snap
@@ -26,14 +26,14 @@ entry:
   ret void
 }
 
-define void @__global_c___ctor(ptr %0) {
+define void @__global_c__ctor(ptr %0) {
 entry:
   %self = alloca ptr, align [filtered]
   store ptr %0, ptr %self, align [filtered]
   ret void
 }
 
-define void @__global_c__ctor(ptr %0) {
+define void @__global_c___ctor(ptr %0) {
 entry:
   %self = alloca ptr, align [filtered]
   store ptr %0, ptr %self, align [filtered]
diff --git a/src/codegen/tests/snapshots/rusty__codegen__tests__debug_tests__global_var_pointer_added_to_debug_info.snap b/src/codegen/tests/snapshots/rusty__codegen__tests__debug_tests__global_var_pointer_added_to_debug_info.snap
index bfc4880d1ba..ea8882b6fc5 100644
--- a/src/codegen/tests/snapshots/rusty__codegen__tests__debug_tests__global_var_pointer_added_to_debug_info.snap
+++ b/src/codegen/tests/snapshots/rusty__codegen__tests__debug_tests__global_var_pointer_added_to_debug_info.snap
@@ -18,14 +18,14 @@ entry:
   ret void
 }
 
-define void @__global_b___ctor(ptr %0) {
+define void @__global_b__ctor(ptr %0) {
 entry:
   %self = alloca ptr, align [filtered]
   store ptr %0, ptr %self, align [filtered]
   ret void
 }
 
-define void @__global_b__ctor(ptr %0) {
+define void @__global_b___ctor(ptr %0) {
 entry:
   %self = alloca ptr, align [filtered]
   store ptr %0, ptr %self, align [filtered]
diff --git a/src/index/tests/snapshots/rusty__index__tests__index_tests__pre_processing_generates_array_of_array_type-2.snap b/src/index/tests/snapshots/rusty__index__tests__index_tests__pre_processing_generates_array_of_array_type-2.snap
index d9d5ee589b1..eae84d46285 100644
--- a/src/index/tests/snapshots/rusty__index__tests__index_tests__pre_processing_generates_array_of_array_type-2.snap
+++ b/src/index/tests/snapshots/rusty__index__tests__index_tests__pre_processing_generates_array_of_array_type-2.snap
@@ -16,7 +16,7 @@ UserTypeDeclaration {
             },
         },
         referenced_type: DataTypeReference {
-            referenced_type: "__arr_arr",
+            referenced_type: "arr_arr_",
         },
         is_variable_length: false,
     },
diff --git a/src/index/tests/snapshots/rusty__index__tests__index_tests__pre_processing_generates_array_of_array_type.snap b/src/index/tests/snapshots/rusty__index__tests__index_tests__pre_processing_generates_array_of_array_type.snap
index e9e94cbda94..b447110727a 100644
--- a/src/index/tests/snapshots/rusty__index__tests__index_tests__pre_processing_generates_array_of_array_type.snap
+++ b/src/index/tests/snapshots/rusty__index__tests__index_tests__pre_processing_generates_array_of_array_type.snap
@@ -5,7 +5,7 @@ expression: new_type
 UserTypeDeclaration {
     data_type: ArrayType {
         name: Some(
-            "__arr_arr",
+            "arr_arr_",
         ),
         bounds: RangeStatement {
             start: LiteralInteger {
diff --git a/src/index/tests/snapshots/rusty__index__tests__index_tests__pre_processing_generates_inline_array_of_array-2.snap b/src/index/tests/snapshots/rusty__index__tests__index_tests__pre_processing_generates_inline_array_of_array-2.snap
index 009dad62248..f3306130ace 100644
--- a/src/index/tests/snapshots/rusty__index__tests__index_tests__pre_processing_generates_inline_array_of_array-2.snap
+++ b/src/index/tests/snapshots/rusty__index__tests__index_tests__pre_processing_generates_inline_array_of_array-2.snap
@@ -5,7 +5,7 @@ expression: new_array_type
 UserTypeDeclaration {
     data_type: ArrayType {
         name: Some(
-            "__foo_inline_array",
+            "__foo_inline_array_",
         ),
         bounds: RangeStatement {
             start: LiteralInteger {
@@ -16,7 +16,7 @@ UserTypeDeclaration {
             },
         },
         referenced_type: DataTypeReference {
-            referenced_type: "__foo_inline_array_",
+            referenced_type: "INT",
         },
         is_variable_length: false,
     },
diff --git a/src/index/tests/snapshots/rusty__index__tests__index_tests__pre_processing_generates_inline_array_of_array.snap b/src/index/tests/snapshots/rusty__index__tests__index_tests__pre_processing_generates_inline_array_of_array.snap
index f3306130ace..009dad62248 100644
--- a/src/index/tests/snapshots/rusty__index__tests__index_tests__pre_processing_generates_inline_array_of_array.snap
+++ b/src/index/tests/snapshots/rusty__index__tests__index_tests__pre_processing_generates_inline_array_of_array.snap
@@ -5,7 +5,7 @@ expression: new_array_type
 UserTypeDeclaration {
     data_type: ArrayType {
         name: Some(
-            "__foo_inline_array_",
+            "__foo_inline_array",
         ),
         bounds: RangeStatement {
             start: LiteralInteger {
@@ -16,7 +16,7 @@ UserTypeDeclaration {
             },
         },
         referenced_type: DataTypeReference {
-            referenced_type: "INT",
+            referenced_type: "__foo_inline_array_",
         },
         is_variable_length: false,
     },
diff --git a/src/index/tests/snapshots/rusty__index__tests__index_tests__pre_processing_generates_inline_array_of_array_of_array-3.snap b/src/index/tests/snapshots/rusty__index__tests__index_tests__pre_processing_generates_inline_array_of_array_of_array-3.snap
index 009dad62248..ee2735c56f7 100644
--- a/src/index/tests/snapshots/rusty__index__tests__index_tests__pre_processing_generates_inline_array_of_array_of_array-3.snap
+++ b/src/index/tests/snapshots/rusty__index__tests__index_tests__pre_processing_generates_inline_array_of_array_of_array-3.snap
@@ -5,7 +5,7 @@ expression: new_array_type
 UserTypeDeclaration {
     data_type: ArrayType {
         name: Some(
-            "__foo_inline_array",
+            "__foo_inline_array__",
         ),
         bounds: RangeStatement {
             start: LiteralInteger {
@@ -16,7 +16,7 @@ UserTypeDeclaration {
             },
         },
         referenced_type: DataTypeReference {
-            referenced_type: "__foo_inline_array_",
+            referenced_type: "INT",
         },
         is_variable_length: false,
     },
diff --git a/src/index/tests/snapshots/rusty__index__tests__index_tests__pre_processing_generates_inline_array_of_array_of_array.snap b/src/index/tests/snapshots/rusty__index__tests__index_tests__pre_processing_generates_inline_array_of_array_of_array.snap
index ee2735c56f7..009dad62248 100644
--- a/src/index/tests/snapshots/rusty__index__tests__index_tests__pre_processing_generates_inline_array_of_array_of_array.snap
+++ b/src/index/tests/snapshots/rusty__index__tests__index_tests__pre_processing_generates_inline_array_of_array_of_array.snap
@@ -5,7 +5,7 @@ expression: new_array_type
 UserTypeDeclaration {
     data_type: ArrayType {
         name: Some(
-            "__foo_inline_array__",
+            "__foo_inline_array",
         ),
         bounds: RangeStatement {
             start: LiteralInteger {
@@ -16,7 +16,7 @@ UserTypeDeclaration {
             },
         },
         referenced_type: DataTypeReference {
-            referenced_type: "INT",
+            referenced_type: "__foo_inline_array_",
         },
         is_variable_length: false,
     },
diff --git a/src/index/tests/snapshots/rusty__index__tests__index_tests__pre_processing_generates_inline_pointer_to_pointer-2.snap b/src/index/tests/snapshots/rusty__index__tests__index_tests__pre_processing_generates_inline_pointer_to_pointer-2.snap
index 363b859cded..a42fc42d473 100644
--- a/src/index/tests/snapshots/rusty__index__tests__index_tests__pre_processing_generates_inline_pointer_to_pointer-2.snap
+++ b/src/index/tests/snapshots/rusty__index__tests__index_tests__pre_processing_generates_inline_pointer_to_pointer-2.snap
@@ -5,10 +5,10 @@ expression: new_pointer_type
 UserTypeDeclaration {
     data_type: PointerType {
         name: Some(
-            "__foo_inline_pointer",
+            "__foo_inline_pointer_",
         ),
         referenced_type: DataTypeReference {
-            referenced_type: "__foo_inline_pointer_",
+            referenced_type: "INT",
         },
         auto_deref: None,
         type_safe: true,
diff --git a/src/index/tests/snapshots/rusty__index__tests__index_tests__pre_processing_generates_inline_pointer_to_pointer.snap b/src/index/tests/snapshots/rusty__index__tests__index_tests__pre_processing_generates_inline_pointer_to_pointer.snap
index a42fc42d473..363b859cded 100644
--- a/src/index/tests/snapshots/rusty__index__tests__index_tests__pre_processing_generates_inline_pointer_to_pointer.snap
+++ b/src/index/tests/snapshots/rusty__index__tests__index_tests__pre_processing_generates_inline_pointer_to_pointer.snap
@@ -5,10 +5,10 @@ expression: new_pointer_type
 UserTypeDeclaration {
     data_type: PointerType {
         name: Some(
-            "__foo_inline_pointer_",
+            "__foo_inline_pointer",
         ),
         referenced_type: DataTypeReference {
-            referenced_type: "INT",
+            referenced_type: "__foo_inline_pointer_",
         },
         auto_deref: None,
         type_safe: true,
diff --git a/src/index/tests/snapshots/rusty__index__tests__index_tests__pre_processing_generates_pointer_to_pointer_type-2.snap b/src/index/tests/snapshots/rusty__index__tests__index_tests__pre_processing_generates_pointer_to_pointer_type-2.snap
index c3ab3de3a3e..6b4198262e6 100644
--- a/src/index/tests/snapshots/rusty__index__tests__index_tests__pre_processing_generates_pointer_to_pointer_type-2.snap
+++ b/src/index/tests/snapshots/rusty__index__tests__index_tests__pre_processing_generates_pointer_to_pointer_type-2.snap
@@ -8,7 +8,7 @@ UserTypeDeclaration {
             "pointer_to_pointer",
         ),
         referenced_type: DataTypeReference {
-            referenced_type: "__pointer_to_pointer",
+            referenced_type: "pointer_to_pointer_",
         },
         auto_deref: None,
         type_safe: true,
diff --git a/src/index/tests/snapshots/rusty__index__tests__index_tests__pre_processing_generates_pointer_to_pointer_type.snap b/src/index/tests/snapshots/rusty__index__tests__index_tests__pre_processing_generates_pointer_to_pointer_type.snap
index 3b872ed6c3c..59dbe6f4e30 100644
--- a/src/index/tests/snapshots/rusty__index__tests__index_tests__pre_processing_generates_pointer_to_pointer_type.snap
+++ b/src/index/tests/snapshots/rusty__index__tests__index_tests__pre_processing_generates_pointer_to_pointer_type.snap
@@ -5,7 +5,7 @@ expression: new_pointer_type
 UserTypeDeclaration {
     data_type: PointerType {
         name: Some(
-            "__pointer_to_pointer",
+            "pointer_to_pointer_",
         ),
         referenced_type: DataTypeReference {
             referenced_type: "INT",
diff --git a/src/lowering/snapshots/rusty__lowering__calls__tests__call_statemements_in_global.snap b/src/lowering/snapshots/rusty__lowering__calls__tests__call_statemements_in_global.snap
index 9ba426d0745..f21c4d45249 100644
--- a/src/lowering/snapshots/rusty__lowering__calls__tests__call_statemements_in_global.snap
+++ b/src/lowering/snapshots/rusty__lowering__calls__tests__call_statemements_in_global.snap
@@ -86,8 +86,4 @@ expression: units.0.global_vars
         ],
         variable_block_type: Global,
     },
-    VariableBlock {
-        variables: [],
-        variable_block_type: Global,
-    },
 ]
diff --git a/src/lowering/snapshots/rusty__lowering__calls__tests__function_wirh_array_of_string_return-3.snap b/src/lowering/snapshots/rusty__lowering__calls__tests__function_wirh_array_of_string_return-3.snap
index e1986bcbe5e..5adc9952a08 100644
--- a/src/lowering/snapshots/rusty__lowering__calls__tests__function_wirh_array_of_string_return-3.snap
+++ b/src/lowering/snapshots/rusty__lowering__calls__tests__function_wirh_array_of_string_return-3.snap
@@ -3,12 +3,7 @@ source: src/lowering/calls.rs
 expression: unit
 ---
 CompilationUnit {
-    global_vars: [
-        VariableBlock {
-            variables: [],
-            variable_block_type: Global,
-        },
-    ],
+    global_vars: [],
     var_config: [],
     pous: [
         POU {
diff --git a/src/lowering/vtable.rs b/src/lowering/vtable.rs
index 7d81beeb2ce..13c59789889 100644
--- a/src/lowering/vtable.rs
+++ b/src/lowering/vtable.rs
@@ -1188,10 +1188,6 @@ mod tests {
 
         insta::assert_debug_snapshot!(units[0].global_vars, @r#"
         [
-            VariableBlock {
-                variables: [],
-                variable_block_type: Global,
-            },
             VariableBlock {
                 variables: [
                     Variable {
diff --git a/src/snapshots/rusty__hardware_binding__tests__hardware_collected_fb.snap b/src/snapshots/rusty__hardware_binding__tests__hardware_collected_fb.snap
index 5c7dacf2b8b..9661c834be4 100644
--- a/src/snapshots/rusty__hardware_binding__tests__hardware_collected_fb.snap
+++ b/src/snapshots/rusty__hardware_binding__tests__hardware_collected_fb.snap
@@ -130,13 +130,13 @@ expression: config
                         Dimension {
                             start_offset: ConstExpression(
                                 Index {
-                                    index: 2,
+                                    index: 0,
                                     generation: 0,
                                 },
                             ),
                             end_offset: ConstExpression(
                                 Index {
-                                    index: 3,
+                                    index: 1,
                                     generation: 0,
                                 },
                             ),
@@ -163,13 +163,13 @@ expression: config
                         Dimension {
                             start_offset: ConstExpression(
                                 Index {
-                                    index: 2,
+                                    index: 0,
                                     generation: 0,
                                 },
                             ),
                             end_offset: ConstExpression(
                                 Index {
-                                    index: 3,
+                                    index: 1,
                                     generation: 0,
                                 },
                             ),
@@ -199,13 +199,13 @@ expression: config
                         Dimension {
                             start_offset: ConstExpression(
                                 Index {
-                                    index: 2,
+                                    index: 0,
                                     generation: 0,
                                 },
                             ),
                             end_offset: ConstExpression(
                                 Index {
-                                    index: 3,
+                                    index: 1,
                                     generation: 0,
                                 },
                             ),
@@ -235,13 +235,13 @@ expression: config
                         Dimension {
                             start_offset: ConstExpression(
                                 Index {
-                                    index: 2,
+                                    index: 0,
                                     generation: 0,
                                 },
                             ),
                             end_offset: ConstExpression(
                                 Index {
-                                    index: 3,
+                                    index: 1,
                                     generation: 0,
                                 },
                             ),
@@ -268,13 +268,13 @@ expression: config
                         Dimension {
                             start_offset: ConstExpression(
                                 Index {
-                                    index: 2,
+                                    index: 0,
                                     generation: 0,
                                 },
                             ),
                             end_offset: ConstExpression(
                                 Index {
-                                    index: 3,
+                                    index: 1,
                                     generation: 0,
                                 },
                             ),
@@ -301,13 +301,13 @@ expression: config
                         Dimension {
                             start_offset: ConstExpression(
                                 Index {
-                                    index: 2,
+                                    index: 0,
                                     generation: 0,
                                 },
                             ),
                             end_offset: ConstExpression(
                                 Index {
-                                    index: 3,
+                                    index: 1,
                                     generation: 0,
                                 },
                             ),
@@ -336,13 +336,13 @@ expression: config
                         Dimension {
                             start_offset: ConstExpression(
                                 Index {
-                                    index: 2,
+                                    index: 0,
                                     generation: 0,
                                 },
                             ),
                             end_offset: ConstExpression(
                                 Index {
-                                    index: 3,
+                                    index: 1,
                                     generation: 0,
                                 },
                             ),
diff --git a/src/tests/adr/initializer_functions_adr.rs b/src/tests/adr/initializer_functions_adr.rs
index d4a43af5718..2ee16c0b876 100644
--- a/src/tests/adr/initializer_functions_adr.rs
+++ b/src/tests/adr/initializer_functions_adr.rs
@@ -437,28 +437,28 @@ fn generating_init_functions() {
       ret void
     }
 
-    define void @__foo___vtable__ctor(ptr %0) {
+    define void @____vtable_foo___body__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @__bar___vtable__ctor(ptr %0) {
+    define void @____vtable_bar___body__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_foo___body__ctor(ptr %0) {
+    define void @__foo___vtable__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_bar___body__ctor(ptr %0) {
+    define void @__bar___vtable__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
@@ -618,14 +618,14 @@ fn intializing_temporary_variables() {
       ret void
     }
 
-    define void @__foo___vtable__ctor(ptr %0) {
+    define void @____vtable_foo___body__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_foo___body__ctor(ptr %0) {
+    define void @__foo___vtable__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
@@ -739,21 +739,21 @@ fn initializing_method_variables() {
       ret void
     }
 
-    define void @__foo___vtable__ctor(ptr %0) {
+    define void @____vtable_foo___body__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_foo___body__ctor(ptr %0) {
+    define void @____vtable_foo_bar__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_foo_bar__ctor(ptr %0) {
+    define void @__foo___vtable__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
@@ -897,28 +897,28 @@ fn initializing_method_variables() {
       ret void
     }
 
-    define void @__foo___vtable__ctor(ptr %0) {
+    define void @____vtable_foo___body__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_foo___body__ctor(ptr %0) {
+    define void @____vtable_foo_bar__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_foo_bar__ctor(ptr %0) {
+    define void @____vtable_foo_baz__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_foo_baz__ctor(ptr %0) {
+    define void @__foo___vtable__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
@@ -1028,21 +1028,21 @@ fn initializing_method_variables() {
       ret void
     }
 
-    define void @__foo___vtable__ctor(ptr %0) {
+    define void @____vtable_foo___body__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_foo___body__ctor(ptr %0) {
+    define void @____vtable_foo_bar__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    define void @____vtable_foo_bar__ctor(ptr %0) {
+    define void @__foo___vtable__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
@@ -1113,10 +1113,10 @@ fn external_initializers() {
 
     declare void @__vtable_foo__ctor(ptr)
 
-    declare void @__foo___vtable__ctor(ptr)
-
     declare void @____vtable_foo___body__ctor(ptr)
 
+    declare void @__foo___vtable__ctor(ptr)
+
     define void @__unit___internal____ctor() {
     entry:
       call void @foo__ctor(ptr @fb_global)
@@ -1217,18 +1217,18 @@ fn external_initializers_in_fbs() {
       ret void
     }
 
-    declare void @__foo___vtable__ctor(ptr)
+    declare void @____vtable_foo___body__ctor(ptr)
 
-    define void @__main___vtable__ctor(ptr %0) {
+    define void @____vtable_main___body__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
       ret void
     }
 
-    declare void @____vtable_foo___body__ctor(ptr)
+    declare void @__foo___vtable__ctor(ptr)
 
-    define void @____vtable_main___body__ctor(ptr %0) {
+    define void @__main___vtable__ctor(ptr %0) {
     entry:
       %self = alloca ptr, align [filtered]
       store ptr %0, ptr %self, align [filtered]
@@ -1345,8 +1345,6 @@ fn external_inherited_initializers() {
       ret void
     }
 
-    declare void @__foo___vtable__ctor(ptr)
-
     declare void @____vtable_foo___body__ctor(ptr)
 
     define void @____vtable_bar___body__ctor(ptr %0) {
@@ -1356,6 +1354,8 @@ fn external_inherited_initializers() {
       ret void
     }
 
+    declare void @__foo___vtable__ctor(ptr)
+
     define void @__unit___internal____ctor() {
     entry:
       call void @__vtable_bar__ctor(ptr @__vtable_bar_instance)
diff --git a/src/validation/tests/assignment_validation_tests.rs b/src/validation/tests/assignment_validation_tests.rs
index 21390b7255d..e0e164c06ec 100644
--- a/src/validation/tests/assignment_validation_tests.rs
+++ b/src/validation/tests/assignment_validation_tests.rs
@@ -1400,11 +1400,11 @@ fn ref_assignment_with_reference_to_array_variable() {
     );
 
     assert_snapshot!(diagnostics, @r"
-    error[E037]: Invalid assignment: cannot assign 'ARRAY[1..6] OF STRING' to 'REFERENCE TO ARRAY[1..5] OF DINT'
+    error[E037]: Invalid assignment: cannot assign 'ARRAY[1..6] OF STRING' to 'ARRAY[1..5] OF DINT'
        ┌─ <internal>:10:13
        │
     10 │             arrReferenceDINT REF= arrSTRING;
-       │             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Invalid assignment: cannot assign 'ARRAY[1..6] OF STRING' to 'REFERENCE TO ARRAY[1..5] OF DINT'
+       │             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Invalid assignment: cannot assign 'ARRAY[1..6] OF STRING' to 'ARRAY[1..5] OF DINT'
     ");
 }
 
diff --git a/src/validation/tests/interface_validation_tests.rs b/src/validation/tests/interface_validation_tests.rs
index de6e54642e5..e5b773d23b4 100644
--- a/src/validation/tests/interface_validation_tests.rs
+++ b/src/validation/tests/interface_validation_tests.rs
@@ -889,7 +889,7 @@ fn interface_with_aggregate_return_type_nested_arrays_mismatch() {
       │                    │      
       │                    see also
 
-    note[E118]: Expected array of type `foo.bar_` but got `STRING`
+    note[E118]: Expected array of type `__foo.bar_return_` but got `STRING`
       ┌─ <internal>:3:20
       │
     3 │             METHOD bar : ARRAY[1..5] OF ARRAY[1..5] OF STRING
@@ -930,7 +930,7 @@ fn interface_with_aggregate_return_type_nested_arrays_dimension_mismatch() {
       │                          -------------------------------------------------------------------- see also
       ·
     8 │             METHOD bar : ARRAY[1..5] OF ARRAY[1..100] OF ARRAY[-2..5] OF ARRAY[1..5] OF STRING
-      │                          --------------------------------------------------------------------- see also
+      │                                         ------------------------------------------------------ see also
 
     note[E118]: Array range declared as `[1..5]` but implemented as `[-2..5]`
       ┌─ <internal>:3:26
@@ -939,7 +939,7 @@ fn interface_with_aggregate_return_type_nested_arrays_dimension_mismatch() {
       │                          -------------------------------------------------------------------- see also
       ·
     8 │             METHOD bar : ARRAY[1..5] OF ARRAY[1..100] OF ARRAY[-2..5] OF ARRAY[1..5] OF STRING
-      │                                         ------------------------------------------------------ see also
+      │                                                          ------------------------------------- see also
     ");
 }
 
@@ -1379,7 +1379,7 @@ fn pointer_to_pointer_return_indirection_level_mismatch() {
     7 │         FUNCTION_BLOCK fb IMPLEMENTS foo
       │                        ^^ Derived methods with conflicting signatures, return types do not match:
 
-    note[E118]: Type `DINT` declared in `foo.bar` but `fb.bar` declared type `fb.bar_`
+    note[E118]: Type `DINT` declared in `foo.bar` but `fb.bar` declared type `__fb.bar_return_`
       ┌─ <internal>:3:20
       │
     3 │             METHOD bar : REF_TO DINT
diff --git a/tests/integration/snapshots/tests__integration__cfc__ir__conditional_return.snap b/tests/integration/snapshots/tests__integration__cfc__ir__conditional_return.snap
index 470b8d88d65..bb8d1f5ef61 100644
--- a/tests/integration/snapshots/tests__integration__cfc__ir__conditional_return.snap
+++ b/tests/integration/snapshots/tests__integration__cfc__ir__conditional_return.snap
@@ -54,14 +54,14 @@ entry:
   ret void
 }
 
-define void @__conditional_return___vtable__ctor(ptr %0) {
+define void @____vtable_conditional_return___body__ctor(ptr %0) {
 entry:
   %self = alloca ptr, align [filtered]
   store ptr %0, ptr %self, align [filtered]
   ret void
 }
 
-define void @____vtable_conditional_return___body__ctor(ptr %0) {
+define void @__conditional_return___vtable__ctor(ptr %0) {
 entry:
   %self = alloca ptr, align [filtered]
   store ptr %0, ptr %self, align [filtered]