createAndInitializeInstance method

InterpretedInstance createAndInitializeInstance(InterpreterVisitor visitor, List<RuntimeType>? typeArguments)

Implementation

InterpretedInstance createAndInitializeInstance(
    InterpreterVisitor visitor, List<RuntimeType>? typeArguments) {
  // Prevent direct instantiation of abstract classes
  if (isAbstract) {
    throw RuntimeD4rtException("Cannot instantiate abstract class '$name'.");
  }

  // Get validated effective type arguments
  final effectiveTypeArgs = _getValidatedTypeArguments(typeArguments);

  // 1. Create the instance with a link to the class
  final instance = InterpretedInstance(this,
      typeArguments: effectiveTypeArgs); // Pass only the class

  // Use the environment where the class was defined as the outer scope
  // for evaluating initializers. We need to traverse the hierarchy.
  final originalVisitorEnv = visitor.environment;

  // Traverse the class hierarchy from top (Object/superclass) down to this class
  List<InterpretedClass> hierarchy = [];
  InterpretedClass? current = this;
  while (current != null) {
    hierarchy.insert(0, current); // Insert at beginning to get top-down order
    current = current.superclass;
  }

  // Initialize fields for each class in the hierarchy
  for (final klassInHierarchy in hierarchy) {
    // Create a temporary environment for this specific class's initializers,
    // enclosing the environment where *that* class was defined.
    final fieldInitEnv =
        Environment(enclosing: klassInHierarchy.classDefinitionEnvironment);
    fieldInitEnv.define('this', instance); // Define 'this' for initializers

    try {
      visitor.environment =
          fieldInitEnv; // Set visitor env for this class's initializers

      // Initialize fields declared IN THIS CLASS
      for (final fieldDecl in klassInHierarchy.fieldDeclarations) {
        if (!fieldDecl.isStatic) {
          for (final variable in fieldDecl.fields?.variables ?? []) {
            final fieldName = variable.name?.name ?? '';
            final isLate = fieldDecl.fields?.isLate ?? false;
            final isFinal = fieldDecl.fields?.isFinal ?? false;

            if (isLate) {
              // Handle late instance field
              if (variable.initializer != null) {
                // Late instance field with lazy initializer
                final lateVar = LateVariable(fieldName, () {
                  // Create a closure that will evaluate the initializer when accessed
                  final savedEnv = visitor.environment;
                  try {
                    visitor.environment = fieldInitEnv;
                    return variable.initializer!.accept<Object?>(visitor);
                  } finally {
                    visitor.environment = savedEnv;
                  }
                }, isFinal: isFinal);
                instance._fields[fieldName] = lateVar;
                Logger.debug(
                    "[Instance Init] Defined late instance field '$fieldName' with lazy initializer.");
              } else {
                // Late instance field without initializer
                final lateVar =
                    LateVariable(fieldName, null, isFinal: isFinal);
                instance._fields[fieldName] = lateVar;
                Logger.debug(
                    "[Instance Init] Defined late instance field '$fieldName' without initializer.");
              }
            } else {
              // Regular field handling
              if (variable.initializer != null) {
                final value = variable.initializer!.accept<Object?>(visitor);
                // Directly set the field on the instance map
                instance._fields[fieldName] = value;
              } else {
                // Ensure field exists even without initializer (Dart default is null)
                instance._fields.putIfAbsent(fieldName, () => null);
              }
            }
          }
        }
      }

      // Initialize fields from MIXINS applied to this class
      // Iterate in application order (0 to n-1) so later mixins overwrite earlier ones
      for (final mixin in klassInHierarchy.mixins) {
        // Each mixin's field initializers run in the mixin's definition environment
        // with 'this' bound to the instance being created.
        final mixinFieldInitEnv =
            Environment(enclosing: mixin.classDefinitionEnvironment);
        mixinFieldInitEnv.define('this', instance);

        // Temporarily set visitor environment for this mixin's initializers
        final originalEnvBeforeMixin = visitor.environment;
        try {
          visitor.environment = mixinFieldInitEnv;
          for (final fieldDecl in mixin.fieldDeclarations) {
            if (!fieldDecl.isStatic) {
              for (final variable in fieldDecl.fields?.variables ?? []) {
                final fieldName = variable.name?.name ?? '';
                if (variable.initializer != null) {
                  final value =
                      variable.initializer!.accept<Object?>(visitor);
                  // Set (or overwrite) the field on the instance
                  instance._fields[fieldName] = value;
                  Logger.debug(
                      "[Instance Init] Initialized mixin field '${klassInHierarchy.name}.$fieldName' from mixin '${mixin.name}' with value: $value");
                } else {
                  // Ensure field exists even if not initialized (Dart default is null)
                  // Only set null if field wasn't already set by class or previous mixin
                  instance._fields.putIfAbsent(fieldName, () {
                    Logger.debug(
                        "[Instance Init] Initialized mixin field '${klassInHierarchy.name}.$fieldName' from mixin '${mixin.name}' to null (default)");
                    return null;
                  });
                }
              }
            }
          }
        } finally {
          // Restore visitor environment after this mixin's initializers
          visitor.environment = originalEnvBeforeMixin;
        }
      }
    } finally {
      // Restore visitor environment after this class's initializers
      visitor.environment = originalVisitorEnv;
    }
  }

  // Instance fields from class hierarchy AND mixins should now be initialized.
  Logger.debug(
      "[Instance Init] Finished instance initialization for '$name'. Fields: ${instance._fields}");

  return instance;
}