Files
carbon-lang/explorer/testdata/assoc_const/bug_multi_impl_scoping.carbon
T
Jon Ross-Perkins 82f33ff384 Use new test framework in explorer to reduce per-test overhead (#2811)
Isolating test execution time (no build time included):

- Linux, `lit` test-per-file: Elapsed time: 28.214s, Critical Path: 13.97s
- Linux, `cc_test`-per-file: Elapsed time: 11.534s, Critical Path: 6.05s
- Linux, merged `cc_test` with 50 shards: Elapsed time: 11.677s, Critical Path: 11.17s
- Mac, `lit` test-per-file: Elapsed time: 295.686s, Critical Path: 20.00s
- Mac, `cc_test`-per-file: Elapsed time: 55.788s, Critical Path: 3.81s
- Mac, merged `cc_test` with 50 shards: Elapsed time: 16.269s, Critical Path: 7.54s

In GH actions:

- [Before](https://github.com/carbon-language/carbon-lang/actions/runs/4866602695/jobs/8678306144?pr=2799):
  - test / test (ubuntu-22.04, fastbuild) (pull_request_target) Successful in 20m
  - test / test (ubuntu-22.04, opt) (pull_request_target) Successful in 15m
  - test / test (macos-12, fastbuild) (pull_request_target) Successful in 36m
  - test / test (macos-12, opt) (pull_request_target) Successful in 21m
- [After](https://github.com/carbon-language/carbon-lang/actions/runs/4875154751/jobs/8697004066?pr=2811):
  - test / test (ubuntu-22.04, fastbuild) (pull_request_target) Successful in 10m
  - test / test (ubuntu-22.04, opt) (pull_request_target) Successful in 9m
  - test / test (macos-12, fastbuild) (pull_request_target) Successful in 12m
  - test / test (macos-12, opt) (pull_request_target) Successful in 9m

I'm still leaving a handful of `lit` tests to test end-to-end binary execution. This is why testdata directories are split (`lit` tests next to the `explorer` binary, the `cc_test`s next to `ParseAndExecute`).
2023-05-15 16:23:59 -07:00

64 lines
1.6 KiB
Plaintext

// Part of the Carbon Language project, under the Apache License v2.0 with LLVM
// Exceptions. See /LICENSE for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
// AUTOUPDATE
// CHECK:STDOUT: (C(i32) as A).FA()
// CHECK:STDOUT: 6
// CHECK:STDOUT: (C(i32) as A).FA()
// CHECK:STDOUT: 7
// CHECK:STDOUT: (C(T) as B).FB()
// CHECK:STDOUT: (C(T) as A).FA()
// CHECK:STDOUT: 3
// CHECK:STDOUT: result: 0
package ExplorerTest api;
interface A {
let TA:! type;
fn FA() -> TA;
}
interface B {
let TB:! type;
fn FB() -> TB;
}
class C(T:! type) {
impl as A & B where .TA = i32 and .TB = i32 {
fn FA() -> i32 {
Print("(C(T) as A).FA()");
// OK, know that TA is i32 here.
let v: Self.(A.TA) = 1;
let w: i32 = v;
return w;
}
fn FB() -> i32 {
Print("(C(T) as B).FB()");
// OK, know that TB is i32 here.
let v: Self.(B.TB) = 2;
// Don't know that TA is i32; it could be specialized.
// TODO: We should not accept this.
let w: Self.(A.TA) = Self.(A.FA)();
return v + w;
}
}
}
external impl C(i32) as A where .TA = (i32, i32) {
fn FA() -> (i32, i32) {
Print("(C(i32) as A).FA()");
return (6, 7);
}
}
fn Main() -> i32 {
Print("{0}", C(i32).(A.FA)()[0]);
Print("{0}", C(i32).(A.FA)()[1]);
// TODO: The implementation of C(T) as B eagerly picked the (non-final)
// implementation of C(T) as A, so this ends up using a different
// implementation of C(i32) as A than the one we just used, violating
// coherence.
Print("{0}", C(i32).(B.FB)());
return 0;
}