visitFunctionDeclaration method

@override void visitFunctionDeclaration(SFunctionDeclaration node)

Visit a SFunctionDeclaration.

Implementation

@override
void visitFunctionDeclaration(SFunctionDeclaration node) {
  final functionName = node.name?.name ?? '';
  Logger.debug(
    "[DeclarationVisitor.visitFunctionDeclaration] Processing function: $functionName",
  );

  if (environment.isDefinedLocally(functionName)) {
    return;
  }

  // Handle type parameters for generic functions
  Environment? tempEnvironment;
  final typeParameters = node.functionExpression?.typeParameters;

  if (typeParameters != null) {
    Logger.debug(
      "[DeclarationVisitor.visitFunctionDeclaration] Function '$functionName' has ${typeParameters.typeParameters.length} type parameters",
    );

    // Create a temporary environment for type resolution
    tempEnvironment = Environment(enclosing: environment);

    // Create temporary type parameter placeholders
    for (final typeParam in typeParameters.typeParameters) {
      final paramName = typeParam.name?.name ?? '';

      // Create a simple TypeParameter placeholder in the temp environment
      final typeParamPlaceholder = TypeParameter(paramName);
      tempEnvironment.define(paramName, typeParamPlaceholder);

      Logger.debug(
        "[DeclarationVisitor.visitFunctionDeclaration]   Defined type parameter '$paramName' in temp environment",
      );
    }
  }

  // Use the temp environment (if any) for type resolution, otherwise use the normal environment
  final resolveEnvironment = tempEnvironment ?? environment;

  // Now resolve the return type (which might reference type parameters)
  final returnTypeNode = node.returnType;
  RuntimeType declaredReturnType;

  if (returnTypeNode is SNamedType) {
    final typeName = returnTypeNode.name?.name ?? '';
    Logger.debug(
      "[DeclarationVisitor.visitFunctionDeclaration]   Return type node name: $typeName",
    );

    try {
      final resolvedType = resolveEnvironment.get(typeName);
      Logger.debug(
        "[DeclarationVisitor.visitFunctionDeclaration]     environment.get('$typeName') resolved to: ${resolvedType?.runtimeType} with name: ${(resolvedType is RuntimeType ? resolvedType.name : 'N/A')}",
      );

      if (resolvedType is RuntimeType) {
        declaredReturnType = resolvedType;
      } else {
        Logger.warn(
          "[DeclarationVisitor.visitFunctionDeclaration]     Type '$typeName' resolved to non-RuntimeType: $resolvedType. Using placeholder.",
        );
        declaredReturnType = BridgedClass(nativeType: Object, name: typeName);
      }
    } on RuntimeD4rtException catch (e) {
      Logger.warn(
        "[DeclarationVisitor.visitFunctionDeclaration]     Type '$typeName' not found in environment (RuntimeError: ${e.message}). Using placeholder.",
      );
      declaredReturnType = BridgedClass(nativeType: Object, name: typeName);
    }
  } else if (returnTypeNode == null) {
    declaredReturnType = BridgedClass(nativeType: Object, name: 'dynamic');
  } else {
    // For other TypeAnnotation types, use a generic placeholder
    declaredReturnType = BridgedClass(
      nativeType: Object,
      name: 'unknown_type_placeholder',
    );
  }

  bool isNullable =
      (returnTypeNode is SNamedType) && returnTypeNode.isNullable;

  // For async functions with Future<T?> return type, extract isNullable from inner type T
  final body0 = node.functionExpression?.body;
  bool isAsync = (body0 is SBlockFunctionBody)
      ? body0.isAsync
      : (body0 is SExpressionFunctionBody)
      ? body0.isAsync
      : false;
  if (isAsync &&
      !isNullable &&
      returnTypeNode is SNamedType &&
      returnTypeNode.name?.name == 'Future') {
    final typeArgs = returnTypeNode.typeArguments;
    if (typeArgs != null && typeArgs.arguments.isNotEmpty) {
      final innerType = typeArgs.arguments.first;
      if (innerType is SNamedType) {
        isNullable = innerType.isNullable;
      }
    }
  }

  final function = InterpretedFunction.declaration(
    node,
    environment, // The function captures the environment it's declared in
    declaredReturnType,
    isNullable,
  );
  Logger.debug(
    "[DeclarationVisitor.visitFunctionDeclaration]   Defining function '$functionName' with declaredReturnType: ${declaredReturnType.name} (Hash: ${declaredReturnType.hashCode})",
  );
  environment.define(functionName, function);
}