pkg/vm/test/transformations/vm_constant_evaluator_test.dart

// Copyright (c) 2023, the Dart project authors.  Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.

import 'dart:io';

import 'package:front_end/src/api_unstable/vm.dart';
import 'package:front_end/src/api_prototype/constant_evaluator.dart'
    show SimpleErrorReporter;
import 'package:kernel/target/targets.dart';
import 'package:kernel/ast.dart';
import 'package:kernel/kernel.dart';
import 'package:kernel/verifier.dart';
import 'package:path/path.dart' as path;
import 'package:test/test.dart';
import 'package:vm/target_os.dart';
import 'package:vm/modular/target/vm.dart' show VmTarget;
import 'package:vm/transformations/unreachable_code_elimination.dart'
    show PlatformConstError, transformComponent;
import 'package:vm/transformations/vm_constant_evaluator.dart';

import '../common_test_utils.dart';

final String pkgVmDir = Platform.script.resolve('../..').toFilePath();

class TestErrorReporter extends SimpleErrorReporter {
  final reportedMessages = <String>[];

  TestErrorReporter();

  @override
  void reportMessage(Uri? uri, int offset, String message) {
    final buffer = StringBuffer();
    if (offset >= 0) {
      if (uri != null) {
        buffer
          ..write(uri.pathSegments.last)
          ..write(':');
      }
      buffer
        ..write(offset)
        ..write(' ');
    }
    buffer
      ..write('Constant evaluation error: ')
      ..write(message);
    reportedMessages.add(buffer.toString());
  }
}

class TestCase {
  final TargetOS os;
  final bool debug;
  final bool enableAsserts;
  final bool throws;

  const TestCase(this.os,
      {required this.debug, required this.enableAsserts, this.throws = false});

  String postfix() {
    String result = '.${os.name}';
    if (debug) {
      result += '.debug';
    }
    if (enableAsserts) {
      result += '.withAsserts';
    }
    return result;
  }
}

class TestOptions {
  static const Option<bool?> debug = Option('--debug', BoolValue(null));

  static const Option<bool?> enableAsserts =
      Option('--enable-asserts', BoolValue(null));

  static const Option<String?> targetOS = Option('--target-os', StringValue());

  static const List<Option> options = [debug, enableAsserts, targetOS];
}

runTestCase(Uri source, TestCase testCase) async {
  final target = new VmTarget(new TargetFlags());
  Component component = await compileTestCaseToKernelProgram(source,
      target: target,
      environmentDefines: {
        'test.define.debug': testCase.debug ? 'true' : 'false',
        'test.define.enableAsserts': testCase.enableAsserts ? 'true' : 'false',
      });

  final reporter = TestErrorReporter();
  final evaluator = VMConstantEvaluator.create(target, component, testCase.os,
      enableAsserts: testCase.enableAsserts, errorReporter: reporter);
  late String actual;
  if (testCase.throws) {
    try {
      component = transformComponent(
          target, component, evaluator, testCase.enableAsserts);
      final kernel =
          kernelLibraryToString(component.mainMethod!.enclosingLibrary);
      fail("Expected compilation failure, got:\n$kernel");
    } on PlatformConstError catch (e) {
      final buffer = StringBuffer();
      for (final message in reporter.reportedMessages) {
        buffer.writeln(message);
      }
      buffer
        ..write('Member: ')
        ..writeln(e.member.name);
      final uri = e.uri;
      if (uri != null) {
        buffer
          ..write('File: ')
          ..writeln(uri.pathSegments.last);
      }
      if (e.offset >= 0) {
        buffer
          ..write('Offset: ')
          ..writeln(e.offset);
      }
      buffer
        ..write('Message: ')
        ..writeln(e.message);
      actual = buffer.toString();
    }
  } else {
    component = transformComponent(
        target, component, evaluator, testCase.enableAsserts);
    if (reporter.reportedMessages.isNotEmpty) {
      fail('Expected no errors, got:\n${reporter.reportedMessages.join('\n')}');
    }
    verifyComponent(
        target, VerificationStage.afterGlobalTransformations, component);
    actual = kernelLibraryToString(component.mainMethod!.enclosingLibrary);
  }
  compareResultWithExpectationsFile(source, actual,
      expectFilePostfix: testCase.postfix());
}

void runWithTargetOS(ParsedOptions? parsedOptions, void Function(TargetOS) fn) {
  TargetOS? specified;
  if (parsedOptions != null) {
    final s = TestOptions.targetOS.read(parsedOptions);
    if (s != null) {
      specified = TargetOS.fromString(s);
      if (specified == null) {
        fail('Failure parsing options: unknown target OS $s');
      }
    }
  }
  if (specified != null) {
    fn(specified);
  } else {
    for (final targetOS in TargetOS.values) {
      fn(targetOS);
    }
  }
}

void runWithBool(Option<bool?> option, ParsedOptions? parsedOptions,
    void Function(bool) fn) {
  bool? specified;
  if (parsedOptions != null) {
    specified = option.read(parsedOptions);
  }
  if (specified != null) {
    fn(specified);
  } else {
    for (final value in [true, false]) {
      fn(value);
    }
  }
}

void runTest(String path, Uri uri, {bool throws = false}) {
  ParsedOptions? options;
  final optionsFile = File('$path.options');
  if (optionsFile.existsSync()) {
    options = ParsedOptions.parse(
        ParsedOptions.readOptionsFile(optionsFile.readAsStringSync()),
        TestOptions.options);
  }

  runWithTargetOS(options, (os) {
    runWithBool(TestOptions.enableAsserts, options, (enableAsserts) {
      runWithBool(TestOptions.debug, options, (debug) {
        final testCase = TestCase(os,
            debug: debug, enableAsserts: enableAsserts, throws: throws);
        test('$path${testCase.postfix()}', () => runTestCase(uri, testCase));
      });
    });
  });
}

main() {
  group('platform-use-transformation', () {
    final testCasesPath = path.join(
        pkgVmDir, 'testcases', 'transformations', 'vm_constant_evaluator');

    group('successes', () {
      final successCasesPath = path.join(testCasesPath, 'successes');
      for (var entry in Directory(successCasesPath)
          .listSync(recursive: true, followLinks: false)
          .reversed) {
        if (entry.path.endsWith('.dart')) {
          runTest(entry.path, entry.uri);
        }
      }
    });

    group('failures', () {
      final errorCasesPath = path.join(testCasesPath, 'errors');

      for (var entry in Directory(errorCasesPath)
          .listSync(recursive: true, followLinks: false)
          .reversed) {
        if (entry.path.endsWith('.dart')) {
          runTest(entry.path, entry.uri, throws: true);
        }
      }
    });
  });
}