Defer the injection of intrinsic routines into System

Some intrinsic routines reference types that are declared in the
`interface` section of `System`, meaning they shouldn't be injected
until the `implementation` section is reached.

However, intrinsic types and constants are referenced within the
`interface` section and should be injected at the beginning.

Author: cirras

delphi-frontend/src/main/java/au/com/integradev/delphi/antlr/ast/visitors/SymbolTableVisitor.java

@@ -54,6 +54,7 @@
 import au.com.integradev.delphi.type.TypeUtils;
 import au.com.integradev.delphi.type.factory.ClassReferenceTypeImpl;
 import au.com.integradev.delphi.type.factory.PointerTypeImpl;
+import au.com.integradev.delphi.type.intrinsic.IntrinsicsInjector;
 import com.google.common.base.Preconditions;
 import com.google.common.collect.Iterables;
 import java.nio.file.Path;
@@ -269,6 +270,22 @@ public Data visit(DelphiAst node, Data data) {
         return super.visit(node, data);
       }
 
+      @Override
+      public Data visit(InterfaceSectionNode node, Data data) {
+        DelphiScope scope = Objects.requireNonNull(data.getUnitDeclaration()).getScope();
+
+        if (scope instanceof SystemScope) {
+          IntrinsicsInjector injector = new IntrinsicsInjector(data.typeFactory);
+          injector.injectTypes(scope);
+          injector.injectConstants(scope);
+          super.visit(node, data);
+          injector.injectRoutines(scope);
+          return data;
+        }
+
+        return super.visit(node, data);
+      }
+
       @Override
       public Data visit(ImplementationSectionNode node, Data data) {
         return data;

delphi-frontend/src/main/java/au/com/integradev/delphi/symbol/scope/SystemScopeImpl.java

@@ -18,7 +18,6 @@
  */
 package au.com.integradev.delphi.symbol.scope;
 
-import au.com.integradev.delphi.type.intrinsic.IntrinsicsInjector;
 import org.sonar.plugins.communitydelphi.api.symbol.declaration.NameDeclaration;
 import org.sonar.plugins.communitydelphi.api.symbol.declaration.TypeNameDeclaration;
 import org.sonar.plugins.communitydelphi.api.symbol.scope.SystemScope;
@@ -32,12 +31,6 @@ public class SystemScopeImpl extends FileScopeImpl implements SystemScope {
 
   public SystemScopeImpl(TypeFactory typeFactory) {
     super("System");
-    injectIntrinsics(typeFactory);
-  }
-
-  private void injectIntrinsics(TypeFactory typeFactory) {
-    IntrinsicsInjector injector = new IntrinsicsInjector(typeFactory);
-    injector.inject(this);
   }
 
   @Override

delphi-frontend/src/main/java/au/com/integradev/delphi/type/intrinsic/IntrinsicConstant.java

@@ -0,0 +1,39 @@
+/*
+ * Sonar Delphi Plugin
+ * Copyright (C) 2025 Integrated Application Development
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02
+ */
+package au.com.integradev.delphi.type.intrinsic;
+
+import org.sonar.plugins.communitydelphi.api.type.IntrinsicType;
+
+final class IntrinsicConstant {
+  private final String name;
+  private final IntrinsicType type;
+
+  public IntrinsicConstant(String name, IntrinsicType type) {
+    this.name = name;
+    this.type = type;
+  }
+
+  public String getName() {
+    return name;
+  }
+
+  public IntrinsicType getType() {
+    return type;
+  }
+}

delphi-frontend/src/main/java/au/com/integradev/delphi/type/intrinsic/IntrinsicsInjector.java

@@ -56,32 +56,45 @@
 import au.com.integradev.delphi.symbol.scope.DelphiScopeImpl;
 import au.com.integradev.delphi.type.factory.TypeFactoryImpl;
 import java.util.ArrayList;
-import java.util.Arrays;
 import java.util.List;
 import org.sonar.plugins.communitydelphi.api.symbol.declaration.RoutineNameDeclaration;
 import org.sonar.plugins.communitydelphi.api.symbol.declaration.TypeNameDeclaration;
+import org.sonar.plugins.communitydelphi.api.symbol.declaration.VariableNameDeclaration;
 import org.sonar.plugins.communitydelphi.api.symbol.scope.DelphiScope;
 import org.sonar.plugins.communitydelphi.api.type.IntrinsicType;
 import org.sonar.plugins.communitydelphi.api.type.Type;
 import org.sonar.plugins.communitydelphi.api.type.TypeFactory;
 
 public final class IntrinsicsInjector {
   private final TypeFactory typeFactory;
+  private final List<IntrinsicConstant> constants;
   private final List<IntrinsicRoutine.Builder> routines;
-  private DelphiScopeImpl scope;
 
   public IntrinsicsInjector(TypeFactory typeFactory) {
     this.typeFactory = typeFactory;
+    this.constants = new ArrayList<>();
     this.routines = new ArrayList<>();
 
+    buildConstants();
     buildRoutines();
   }
 
-  public void inject(DelphiScope scope) {
-    this.scope = (DelphiScopeImpl) scope;
-    injectTypes();
-    injectRoutines();
-    injectConstants();
+  public void injectTypes(DelphiScope scope) {
+    for (IntrinsicType type : IntrinsicType.values()) {
+      injectType(type, (DelphiScopeImpl) scope);
+    }
+  }
+
+  public void injectConstants(DelphiScope scope) {
+    for (IntrinsicConstant constant : constants) {
+      injectConstant(constant, (DelphiScopeImpl) scope);
+    }
+  }
+
+  public void injectRoutines(DelphiScope scope) {
+    for (IntrinsicRoutine.Builder routine : routines) {
+      injectRoutine(routine, (DelphiScopeImpl) scope);
+    }
   }
 
   private Type type(IntrinsicType type) {
@@ -96,6 +109,16 @@ private Type dynamicArraySizeType() {
     return ((TypeFactoryImpl) typeFactory).dynamicArraySizeType();
   }
 
+  private void buildConstants() {
+    constant("CompilerVersion", EXTENDED);
+    constant("MaxInt", INTEGER);
+    constant("MaxLongInt", LONGINT);
+    constant("True", BOOLEAN);
+    constant("False", BOOLEAN);
+    constant("ReturnAddress", POINTER);
+    constant("AddressOfReturnAddress", POINTER);
+  }
+
   private void buildRoutines() {
     routine("Abs").param(type(REAL)).returns(type(REAL));
     routine("Abs").param(type(INTEGER)).returns(type(INTEGER));
@@ -344,17 +367,17 @@ private void buildRoutines() {
     routine("WriteLn").variadic(TypeFactory.untypedType());
   }
 
+  private void constant(String name, IntrinsicType type) {
+    constants.add(new IntrinsicConstant(name, type));
+  }
+
   private IntrinsicRoutine.Builder routine(String name) {
     IntrinsicRoutine.Builder builder = IntrinsicRoutine.builder(name);
     routines.add(builder);
     return builder;
   }
 
-  private void injectTypes() {
-    Arrays.stream(IntrinsicType.values()).forEach(this::injectType);
-  }
-
-  private void injectType(IntrinsicType intrinsic) {
+  private void injectType(IntrinsicType intrinsic, DelphiScopeImpl scope) {
     SymbolicNode node = SymbolicNode.imaginary(intrinsic.simpleName(), scope);
     Type type = typeFactory.getIntrinsic(intrinsic);
     TypeNameDeclaration declaration =
@@ -363,11 +386,7 @@ private void injectType(IntrinsicType intrinsic) {
     scope.addDeclaration(declaration);
   }
 
-  private void injectRoutines() {
-    routines.forEach(this::injectRoutine);
-  }
-
-  private void injectRoutine(IntrinsicRoutine.Builder builder) {
+  private void injectRoutine(IntrinsicRoutine.Builder builder, DelphiScopeImpl scope) {
     IntrinsicRoutine routine = builder.build();
     SymbolicNode node = SymbolicNode.imaginary(routine.simpleName(), scope);
     RoutineNameDeclaration declaration =
@@ -376,18 +395,11 @@ private void injectRoutine(IntrinsicRoutine.Builder builder) {
     scope.addDeclaration(declaration);
   }
 
-  private void injectConstants() {
-    injectConstant("CompilerVersion", EXTENDED);
-    injectConstant("MaxInt", INTEGER);
-    injectConstant("MaxLongInt", LONGINT);
-    injectConstant("True", BOOLEAN);
-    injectConstant("False", BOOLEAN);
-    injectConstant("ReturnAddress", POINTER);
-    injectConstant("AddressOfReturnAddress", POINTER);
-  }
+  private void injectConstant(IntrinsicConstant constant, DelphiScopeImpl scope) {
+    String name = constant.getName();
+    Type type = type(constant.getType());
+    VariableNameDeclaration declaration = VariableNameDeclarationImpl.constant(name, type, scope);
 
-  private void injectConstant(String image, IntrinsicType intrinsic) {
-    var declaration = VariableNameDeclarationImpl.constant(image, type(intrinsic), scope);
     scope.addDeclaration(declaration);
   }
 }