Enable references to system types in intrinsic routine signatures

Now that we defer the injection of intrinsic routines into `System`, we
can resolve public `System` types for intrinsic parameter types and
return types.

Author: cirras

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

@@ -25,6 +25,8 @@
 import org.sonar.plugins.communitydelphi.api.symbol.Qualifiable;
 import org.sonar.plugins.communitydelphi.api.symbol.QualifiedName;
 import org.sonar.plugins.communitydelphi.api.symbol.declaration.RoutineKind;
+import org.sonar.plugins.communitydelphi.api.symbol.declaration.TypedDeclaration;
+import org.sonar.plugins.communitydelphi.api.symbol.scope.DelphiScope;
 import org.sonar.plugins.communitydelphi.api.type.Type;
 import org.sonar.plugins.communitydelphi.api.type.TypeFactory;
 
@@ -123,8 +125,9 @@ Builder hasDefaultValue(boolean hasDefaultValue) {
         return this;
       }
 
-      IntrinsicParameterData build() {
-        return new IntrinsicParameterData(type, isOut, isVar, isConst, hasDefaultValue);
+      IntrinsicParameterData build(DelphiScope scope) {
+        Type resolvedType = resolveType(type, scope);
+        return new IntrinsicParameterData(resolvedType, isOut, isVar, isConst, hasDefaultValue);
       }
     }
   }
@@ -185,26 +188,43 @@ Builder returns(Type returnType) {
       return this;
     }
 
-    IntrinsicRoutine build() {
+    IntrinsicRoutine build(DelphiScope scope) {
       return new IntrinsicRoutine(
-          routineName, buildParameters(), returnType, variadicParameter != null);
+          routineName, buildParameters(scope), buildReturnType(scope), variadicParameter != null);
     }
 
-    private List<IntrinsicParameterData> buildParameters() {
+    private List<IntrinsicParameterData> buildParameters(DelphiScope scope) {
       List<IntrinsicParameterData> result = new ArrayList<>();
 
       for (int i = 0; i < parameters.size(); ++i) {
         IntrinsicParameterData.Builder paramBuilder = parameters.get(i);
         paramBuilder.hasDefaultValue(requiredParameters != -1 && i >= requiredParameters);
-        result.add(paramBuilder.build());
+        result.add(paramBuilder.build(scope));
       }
 
       if (variadicParameter != null) {
         variadicParameter.hasDefaultValue(true);
-        result.add(variadicParameter.build());
+        result.add(variadicParameter.build(scope));
       }
 
       return result;
     }
+
+    private Type buildReturnType(DelphiScope scope) {
+      return resolveType(returnType, scope);
+    }
+  }
+
+  private static Type resolveType(Type type, DelphiScope scope) {
+    if (type.isUnresolved()) {
+      String simpleName = type.getImage();
+      type =
+          scope.getTypeDeclarations().stream()
+              .filter(declaration -> declaration.getName().equalsIgnoreCase(simpleName))
+              .map(TypedDeclaration::getType)
+              .findFirst()
+              .orElse(type);
+    }
+    return type;
   }
 }

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

@@ -54,6 +54,7 @@
 import au.com.integradev.delphi.symbol.declaration.TypeNameDeclarationImpl;
 import au.com.integradev.delphi.symbol.declaration.VariableNameDeclarationImpl;
 import au.com.integradev.delphi.symbol.scope.DelphiScopeImpl;
+import au.com.integradev.delphi.type.UnresolvedTypeImpl;
 import au.com.integradev.delphi.type.factory.TypeFactoryImpl;
 import java.util.ArrayList;
 import java.util.List;
@@ -101,6 +102,10 @@ private Type type(IntrinsicType type) {
     return typeFactory.getIntrinsic(type);
   }
 
+  private Type systemType(String image) {
+    return UnresolvedTypeImpl.referenceTo(image);
+  }
+
   private Type openArraySizeType() {
     return ((TypeFactoryImpl) typeFactory).openArraySizeType();
   }
@@ -387,7 +392,7 @@ private void injectType(IntrinsicType intrinsic, DelphiScopeImpl scope) {
   }
 
   private void injectRoutine(IntrinsicRoutine.Builder builder, DelphiScopeImpl scope) {
-    IntrinsicRoutine routine = builder.build();
+    IntrinsicRoutine routine = builder.build(scope);
     SymbolicNode node = SymbolicNode.imaginary(routine.simpleName(), scope);
     RoutineNameDeclaration declaration =
         RoutineNameDeclarationImpl.create(node, routine, typeFactory);