Commit Graph
773 Commits
Author SHA1 Message Date
Jon Ross-Perkins 8fb5bcedd5 Add range flag settings to interface files (#5563)
Where `--no-dump-sem-ir` is used, change to `--dump-sem-ir-ranges=only`.
Otherwise, add `--dump-sem-ir-ranges=if-present` with a TODO to change
to `only`.

Note, SemIR is affected just because the extra comments change line
numbers in files where splits aren't in use.
2025-05-29 18:41:55 +00:00
Jon Ross-Perkins 0b8fa690cd Add range flag settings to let files (#5565)
Where `--no-dump-sem-ir` is used, change to `--dump-sem-ir-ranges=only`.
Otherwise, add `--dump-sem-ir-ranges=if-present` with a TODO to change
to `only`.

Note, SemIR is affected just because the extra comments change line
numbers in files where splits aren't in use.
2025-05-29 18:35:15 +00:00
Jon Ross-Perkins cef617ac02 Add range flag settings to facet files (#5557)
Where `--no-dump-sem-ir` is used, change to `--dump-sem-ir-ranges=only`.
Otherwise, add `--dump-sem-ir-ranges=if-present` with a TODO to change
to `only`.

Note, SemIR is affected just because the extra comments change line
numbers in files where splits aren't in use.
2025-05-29 18:33:37 +00:00
Jon Ross-Perkins 3fb4d9a468 Add range flag settings to class files (#5556)
Where `--no-dump-sem-ir` is used, change to `--dump-sem-ir-ranges=only`.
Otherwise, add `--dump-sem-ir-ranges=if-present` with a TODO to change
to `only`.

Note, SemIR is affected just because the extra comments change line
numbers in files where splits aren't in use.
2025-05-29 18:32:57 +00:00
Jon Ross-Perkins 6318987343 Add range flag settings to generic files (#5559)
Where `--no-dump-sem-ir` is used, change to `--dump-sem-ir-ranges=only`.
Otherwise, add `--dump-sem-ir-ranges=if-present` with a TODO to change
to `only`.

Note, SemIR is affected just because the extra comments change line
numbers in files where splits aren't in use.
2025-05-29 18:19:58 +00:00
Jon Ross-Perkins 270174cd82 Move the ir test (#5510)
This test has its own directory, since #3056. We haven't added any more,
so fold it into basics. Also simplify it a little using `else`, and
`no_prelude`.

Note, I'm not even sure how much we need this test given the
`%.loc<line>_<col>`, but I feel slightly worse deleting it.
2025-05-27 23:31:22 +00:00
Dana Jansens 69ab97d716 Don't wrap an ErrorInst as a subpattern of another pattern (#5542)
When a pattern is an error, avoid wrapping it as a subpattern in a
RefParamPattern or VarPattern. This allows further error handling to
observe the error occurred without having to unwrap it.

This avoids a crash when an invalid associated constant is written which
has a VarPattern in it. The associated constant machinery expects an
AssociatedConstantDecl but was getting a VarPattern with an ErrorInst
inside. Now it receives an ErrorInst directly, which it is already
looking for.

This choice means that `var` statements in an `interface` will always be
diagnosed as being non-constant, or as being a constant with a `var`, so
we don't need an extra diagnostic saying that `var` is not allowed in an
interface, as this just leads to two diagnostics on the same thing.

This crash was found by a fuzzer.
2025-05-27 18:13:12 +00:00
Jon Ross-Perkins 3946cac281 Update const tests for splits, preludes, and ranges (#5532) 2025-05-27 17:05:33 +00:00
Boaz Brickner 0a5dc9a9cc Use C++ trailing return type in toolchain/check/testdata/interop/cpp/no_prelude/function.carbon (#5541) 2025-05-27 16:20:00 +00:00
Jon Ross-Perkins 90649d60f0 Fix crash on 'destroy' with return type and no params (#5527)
Fuzzer-found crash
2025-05-23 19:33:06 +00:00
Jon Ross-Perkins cea9954e28 Update basics tests for ranges, splits, and min_prelude (#5509)
Updating tests in the style of
https://github.com/carbon-language/carbon-lang/pull/5455.

- Moving `Run`-specific tests into their own directory, with a README to
explain why it's unusual.
  - Note, I suspect we'll also get more over time (e.g., with arguments)
- This makes a little more use of `if-present` just because there are
more tests that want to print their full output.
- I'm combining the two empty-ish tests, thought I do still want the
*really* empty one to be fully empty (i.e., no tokens provided by the
file).
- Dropping multifile.carbon because it doesn't seem like an interesting
test to keep.
2025-05-23 17:50:02 +00:00
Dana JansensandJon Ross-Perkins 5aea18f949 Avoid resolving the decl block for specifics in imported instructions (#5517)
Move the operation of resolving the specific decl block from
`GetConstantValue()` to `TryEvalTypedInst()`, with is now happening
after replacing the fields of the instruction with new constant values,
but before running the evaluation of the instruction. Since imported
instructions are not evaluated, this avoids resolving the specific decl
block from imported instructions, resolving a TODO in
`AddImportedConstant()`. Now `AddImportedConstant()` can replace
constant values in its fields without having to worry about that
operation resolving any specific decl blocks.

We get to add a new TODO however, to explain why we still need a special
case in resolving specific decl blocks for handling `Impl` construction.
The witness table contains instructions with specifics referring to the
generic self of the impl declaration. But the table must be constructed
before the impl's generic is finished, in order to make the instructions
dependent for the generic. But then resolving the specific decl block
can't be done when the instructions are created and evaluated, as that
requires a finished generic.

---------

Co-authored-by: Jon Ross-Perkins <jperkins@google.com>
2025-05-23 16:58:46 +00:00
Jon Ross-Perkins 2c013ada42 Update choice tests for ranges (#5525)
Note the amount of IR excluded is pretty small, but non-zero (mainly
prelude-related, due to the way a choice depends on `UInt`)

Renaming fail_todo_params.carbon to just params.carbon, and folding in
fail_invalid.carbon.
2025-05-22 22:34:12 +00:00
Jon Ross-PerkinsandDavid Blaikie b310958600 Update builtins tests for ranges (#5512)
Updating tests in the style of
https://github.com/carbon-language/carbon-lang/pull/5455.

Notable things for builtins:

- #4748 disabled semir output in int tests, but not other tests. After
discussion with zygoloid, adding ranges just for runtime calls that seem
significant. The rest can rely on type checking to demonstrate
correctness.
- Fixes cases of things like `RuntimeCallIsValidBadReturnType` using the
wrong number of args, and being invalid as a result.
- Splits out the too few, too many, and bad return type tests -- I think
this helps highlight where the above is an issue.
- Expands use of `library "[[@TEST_NAME]]";` in tests where package
names were previously in use.

Ranges tests were already updated for splits, so not really touching
that. Also, the prelude interaction gets a little gnarly because these
also partly test prelude bits.

---------

Co-authored-by: David Blaikie <dblaikie@gmail.com>
2025-05-22 21:31:56 +00:00
Dana Jansensandjosh11b 950d83451a Add diagnostics for invalid impl declarations (#5420)
Outside of `match_first` this adds diagnostics for invalid non-final and
final `impl` declarations in line with those being proposed in
https://github.com/carbon-language/carbon-lang/pull/5337.

- Two non-final `impl`s with the exact same type structure is invalid.
- A `final impl` that matches the self/constraint of another `impl` as a
query would always be preferred, making the second one invalid.
- Two `final impl`s that overlap (have compatible type structures) in
different files is invalid.
- Two `final impl`s that overlap (have compatible type structures) in
the same file is invalid outside of `match_first`.
- A `final impl` in a different file from its root self type and
interface is invalid.

We add tests for all these scenarios as well as correct scenarios.

The "compatible" test for two type structures was being done
symmetrically, which is incorrect. We want it to test that a query type
structure is the same _or more specific_ in a compatible way with an
impl's type structure. This is corrected in the implementation, and the
diagnostics now have to test both directions to get the desired output,
as expected.

---------

Co-authored-by: josh11b <15258583+josh11b@users.noreply.github.com>
2025-05-22 18:58:47 +00:00
Dana Jansens dd1b010b01 Add missing library in destroy_calls.carbon test file split (#5518) 2025-05-22 16:31:58 +00:00
Jon Ross-Perkins 66b51923d7 Update as tests for ranges, splits, and min_prelude (#5508)
Updating tests in the style of
https://github.com/carbon-language/carbon-lang/pull/5455.

I'm leaving adapter_conversion.carbon pretty much as-is because of the
`adapt_i32.carbon` test, which I'm not clear how critical `i32` is there
but feels specific enough that maybe it can't be `min_prelude`. Other
tests felt all pretty reasonable to adjust to `min_prelude` and a single
file (`basics.carbon`).
2025-05-21 22:26:05 +00:00
Jon Ross-Perkins c1eea8f2eb Update array tests for ranges, splits, and min_prelude (#5507)
Updating tests in the style of #5455.

array indexing requires integers, so this is a more prelude-dependent
area than some. But as it turns out, writing something like `3` never
references `Core.IntLiteral` so seeing if I can roll with more minimal
preludes.
2025-05-21 19:12:02 +00:00
Richard Smith 5b884ae14d Improve lowering for global variables. (#5492)
- Track the `VarPattern` instruction on the `VarStorage` instruction so
that it's available for name mangling.
- Mangle global variables based on the first binding name within their
pattern.
- Give global variables external rather than internal linkage, except if
they have no bindings whatsoever in their pattern.
- To support lowering references to bindings nested within a global var,
such as for `var (x: i32, b: i32)`, add some basic initial support for
reference constant expressions. Treat a global `var` as a reference
constant, and treat an aggregate access into a reference constant as a
reference constant.
2025-05-21 00:09:10 +00:00
Boaz Brickner c39efe321e Refactor toolchain/check/testdata/interop/cpp/no_prelude/function_decl.carbon (#5477)
Rename file and shard files to shorter name given context.
Add `todo_` to file shards where appropriate.
Add shard files section comments.
2025-05-20 16:15:49 +00:00
Geoff RomerandRichard Smith fbc5994750 Support importing var parameters (#5400)
This restructures the import and merge logic to support parameter
patterns in a more scalable way.

---------

Co-authored-by: Richard Smith <richard@metafoo.co.uk>
2025-05-19 22:50:16 +00:00
Boaz Brickner 8e666cea3e Add section descriptions in toolchain/check/testdata/interop/cpp/no_prelude/cpp_diagnostics.carbon as agreed in #5467 (#5497)
Part of #4666.
2025-05-19 21:39:57 +00:00
Boaz Brickner 04d2643fd7 Reformat banner comments in toolchain/check/testdata/interop/cpp/function_param_*.carbon , following the agreed format in #5467 (#5498)
I've decided to keep `int` and similar as low case, as it refers to an
actual type.

Part of #5436
2025-05-19 21:17:23 +00:00
Geoff Romer 9e2ad3e454 Use GetWithAttachedType consistently in import (#5483)
This unblocks merging #5400.
2025-05-19 20:12:56 +00:00
Boaz Brickner 6842c51fd1 Rename toolchain/check/testdata/interop/cpp/no_prelude/function_decl_inline.carbon and its shard files to simpler names (#5476)
Part of #5405.
2025-05-18 23:30:47 +00:00
Boaz Brickner 42f4d20e36 Improve toolchain/check/testdata/interop/cpp/no_prelude/namespace.carbon (#5478)
* Add // === headlines on group of file shards.
* Rename shard files to shorten given the file context them and add
`todo` where appropriate and group them together..
2025-05-17 15:17:41 +00:00
Jon Ross-Perkins 100a4f038d Update tests of alias for ranges, splits, and min_prelude (#5455)
Doing a few things here, to sound people out on a broader test cleanup:

1. Adding `--dump-sem-ir-ranges=<value>` to all files.
- The default is currently `if-present`. I'd like to change the default
to `only` in tests. Always setting it both makes it clear which tests
have been looked at as part of cleanup, and makes changing the default a
simpler "remove" action (versus "find changed tests and add lines").
- I'm only using `if-present` in import tests; ranges would hide
imported instructions, but I think the imported instructions are more
relevant in those.
2. Removing `--no-dump-sem-ir` uses.
- `--dump-sem-ir-ranges=only` has similar results to `--no-dump-sem-ir`,
so this is partly consolidating.
- Relying on the "only" value allows for easier combining of test files
into splits.
3. Evaluating where splits may be used.
    - Historically, we had to have each test be an individual file.
4. Preferring files with a split named `fail_` over files that use the
default name.
- I think this makes test files a little more consistently named, and
should ease the path if people want to add more split tests (vs pushing
people towards adding files).
- But I can switch back for single-split tests if the leaning is more
that we shouldn't repeat.

Specific to an `alias`, significant notes:

1. Consolidates several tests into a `basics.carbon` test.
- In there, adds a simple alias test; I didn't immediately see a trivial
test like that.
2. The "aliased_name_in_diag" test was no longer testing what it was
supposed to; however, there's "preserve_in_type_printing" so I'm
removing it as duplicative (vs switching to a min_prelude test).
3. Moves out a control flow test that didn't appear related to `alias`.
2025-05-16 23:22:10 +00:00
Jon Ross-Perkins e78a57bb82 Adjust formatting of blocks and scopes (#5474)
This is making two inter-related changes:

- Change `file` to reuse the formatter logic of `constants` and
`imports`, meaning empty `file` scopes will be omitted
- Mark `<elided>` sections in blocks (not in non-block scopes, because
they're not as sequential)
2025-05-16 22:50:28 +00:00
Dana Jansens e9823df130 Update the test comment explaining the fix for #5481 (#5488)
The fix for #5481 changed but the comment explaining what needs to
happen (and now happens due to the #5481 PR) was not updated.
2025-05-15 17:00:09 +00:00
Dana Jansens 4f59fb1346 Substitute into the type of BindSymbolicName or SymbolicBindingPattern (#5481)
When a `LookupImplWitness` instruction is created in a generic function
for a witness obtained from a `BindSymbolicName`, it stores the
`BindSymbolicName` as the query self type along with the interface it
obtained from it.

Later, when an argument is substituted into the `LookupImplWitness` in
deduction, and it is re-evaluated, the `BindSymbolicName` in the query
interface's specific arguments was being substituted, but the same
`BindSymbolicName` in the query self type was not. This was because we
did not substitute into the type of `BindSymbolicName`. In this case the
type is a `FacetType` which has inside it one or more specific
interfaces. The same substitution needs to be applied to both the
interfaces in the self type as to the interfaces in the query.

This issue was found by a fuzzer - though in a weirder and more invalid
way, by putting all of the code for our test case inside an `interface`,
which creates an implicit generic `Self` in the enclosing context and
yet makes it concrete inside a function body.
2025-05-15 16:30:32 +00:00
Dana Jansens 3d07794650 Gracefully error in non-compound member lookup into a runtime facet value (#5485)
And update tests to clarify that we should be able to do lookup into a
runtime facet value for an associated constant if the FacetType itself
provides that constant (with a `where` clause), but should not be able
to if it does not.

This fixes a fuzzer-found crash.
2025-05-15 16:25:53 +00:00
Dana Jansens 8b087738b7 Handle FunctionType and FunctionTypeWithSelfType in TypeIterator without crashing (#5480)
A fuzzer found that converting a pointer to a `FunctionTypeWithSelfType`
to `type` does an impl lookup and ends up in TypeIterator with the
`FunctionTypeWithSelfType` being iterated over in the self type, where
we crash. It's a valid type, so the iterator should be able to walk over
and return it.

We also constructed a similar example for `FunctionType`.
2025-05-15 13:25:38 +00:00
Boaz Brickner 4071372677 Improve toolchain/check/testdata/interop/cpp/no_prelude/{class,struct,union}.carbon (#5467)
* Add // === headlines on group of file shards.
* Rename shard files to shorten given the file context them and add
`todo` where appropriate.

Not splitting this file for now.

Part of #5150.
2025-05-15 09:01:18 +00:00
Boaz Brickner 2b48033da7 Refactor toolchain/check/testdata/interop/cpp/function_decl.carbon (#5457)
* Split to 4 files: `function_param_int16`, `function_param_int32`,
`function_param_unsupported.carbon`, `function_return`.
* Add // === headlines on group of file shards.
* Rename shard files to shorten them and make them more consistent given
the file context.
* Deduplicate identical .h files and group their tests.

Potential future improvements:
* Split further. For example, pointers and references might be somewhat
separate from int primitives.
* Remove `import_` shard file prefix, as it repeats itself, but leaving
for now as it makes it more explicit.

Part of #5263
2025-05-14 16:00:27 +00:00
Jon Ross-Perkins dc61460b5a Change default flags for min_prelude tests (#5471)
I think this would probably have prevented the missed include in #5469
-- it would've just failed completely with a "missing prelude"
diagnostic.

Also note this excludes the included IR from output, because it's
probably low-value to print.
2025-05-13 18:02:24 +00:00
Dana Jansens 55849f43f3 Make patterns/min_prelude/underscore.carbon into a min_prelude test (#5469)
The test was placed under a `min_prelude/` path prefix but the
--custom-core and min-prelude include had been omitted.
2025-05-13 17:30:19 +00:00
Dana Jansens 010efd2e40 Preserve the is_final bit when importing an impl declaration (#5461)
We were importing all impls as non-final, since we forgot to set the new
field when constructing the imported Impl. Adds a test that fails before
this PR, since the imported Impl is treated as non-final.
2025-05-12 18:10:36 +00:00
Jon Ross-Perkins cc416171e2 Have FormatScopeIfUsed consider ranges before printing (#5454)
If there will be no in-scope instructions printed, have
`FormatScopeIfUsed` skip the relevant scope.

Note, this only affects constants and imports. It's not changing the
file scope, which is usually printed when empty.
2025-05-12 15:55:03 +00:00
Jon Ross-Perkins 937caaecce Add --dump-sem-ir-ranges for controlling dump output (#5450)
Right now, a lot of tests have started setting `--no-dump-sem-ir`. My
thought is that we can look at:

1. Put ranges in a bunch more files.
2. Shift more towards `--dump-sem-ir-ranges=only` instead of
`--no-dump-sem-ir`, because it allows mixing fail-tests with no IR
alongside tests that contain IR.
3. Evaluate switching the default to `--dump-sem-ir-ranges=only`, and
instead set `--dump-sem-ir-ranges=if-present` only in files that want to
typically show all IR (particularly import-related tests, where ranges
don't work well).

In real-world use, my thought is also that it'd be helpful to be able to
add the dump range comments to files, see the output (i.e., the default
behavior of `if-present`) but then also be able to pass `ignore` in
order to see the full IR without modifying the file (possibly also
useful in tests). That model is why I went for tri-state handling.

Note `only` can also have an interesting side-effect. Because core files
(including min_prelude versions) typically won't have ranges, they'd be
implicitly excluded.
2025-05-12 14:51:10 +00:00
Dana Jansens b6a55c0818 Diagnose impls that are fully overlapped by a final impl (#5417)
Such impls will never be used, so they should not exist. And test that a
final impl partially overlapping a non-final impl is accepted.

There is a question about a final impl partially overlapping a final
impl that is part of
https://github.com/carbon-language/carbon-lang/pull/5337
2025-05-10 17:36:28 +00:00
Boaz Brickner 2cb0df42e0 Add C++ interop inline function tests (#5406)
This shows that `inline` is ignored and the function definition is not
generated.

Demo:

```c++
// hello_world.h

inline void hello_world() {}
```

```carbon
// main.carbon

library "Main";

import Cpp library "hello_world.h";

fn Run() -> i32 {
  Cpp.hello_world();
  return 0;
}
```

```shell
$ bazel-bin/toolchain/carbon compile main.carbon
$ bazel-bin/toolchain/carbon link main.o --output=demo
ld.lld: error: undefined symbol: hello_world()
>>> referenced by main.carbon:8
>>>               main.o:(main)
error: linker command failed with exit code 1 (use -v to see invocation)
```

Part of #5405.
2025-05-09 16:33:16 +00:00
Ivana Ivanovska f8443ae09e [Carbon/C++ interop] Add support for C++ type short (#5393)
Added support for `short`/`int16_t`. Both function parameters and return
values this type will be supported.

Demo:

```c++
// hello_short.h

#include <cstdint>
auto foo_short(int16_t a) -> int16_t;
```

```c++
// hello_short.cpp

#include "hello_short.h"
#include <cstdio>

auto foo_short(int16_t a) -> int16_t {
    printf("a = %i \n", a);
    return a;
}
```

```c++
// main.carbon

library "Main";

import Cpp library "hello_short.h";
import Core library "io";

fn Run() -> i32 {
  var a: i16 = 3;
  Cpp.foo_short(a);
  return 0;
}
```

```
$ clang -c hello_short.cpp
$ bazel-bin/toolchain/carbon compile main.carbon
$ bazel-bin/toolchain/carbon link hello_short.o main.o --output=demo
$ ./demo
a = 3 
```

Part of #5263
2025-05-09 08:51:46 +00:00
Dana Jansens e6a6624ec6 Include concrete non-type values in the type structure and use for impl candidate selection (#5431)
Non-type values were being represented as "Concrete" in the type
structure's shape, which was incorrect when the value was symbolic. Now
they are represented as "Concrete" or "Symbolic" as appropriate.

When concrete, a matching concrete ConstantId is stored in the type
structure's concrete values, so that they will be used for equality
comparison. And then impl matching comparison is taught to look in the
concrete values for mismatches when it finds a "Concrete" or
"ConcreteOpenParen" shape on both sides of the comparison, and return
false if they are not equal. This reduces the number of candidate impls
selected in impl lookup, which avoids doing type deduction against impls
that won't match anyway due to the concrete values in the query not
matching concrete values in the impl. As a result we see fewer specifics
being generated in the semir.
2025-05-08 18:41:36 +00:00
Dana Jansens a9a94b03ac Pull type iteration out into a TypeIterator, build the TypeStructureBuilder on it (#5430)
The TypeStructureBuilder recursively iterates through a type, interface,
or facet value and constructs a type structure that includes each
concrete and symbolic value found. This iteration is a more general
thing that can be useful elsewhere. For instance, to get just the root
type out of a general type, it is the result of the first iteration
step.

We abstract out the iteration logic into a SemIR::TypeIterator to create
a clear boundary between the work of iterating and the work of building
the TypeStructure from it.

Along the way this pointed out some issues in the TypeStructureBuilder
where it could have ambiguity between types that include non-type
values. So we add some tests for these cases, and they now pass. There
are also TODOs left behind, as concrete TypeStructure is overly specific
right now in order to keep these tests passing, which means that the
concrete elements can't be used for impl lookup matching yet. Only the
shape of concrete vs symbolic is used for now, and then type deduction
is used to compare the actual concrete types, which could be skipped
when the concrete values could be compared directly and reject an impl
for not matching.
2025-05-08 16:46:45 +00:00
Ivana Ivanovska afea14d14d [Carbon/C++ interop] Add more tests for int function params support (#5392)
Added tests for `signed int`, `signed`, `std::int32_t` and `const int&`.
This is an addition to PR #5197.

Part of #5064
2025-05-08 13:57:34 +00:00
Richard Smith f2a16d8742 Don't crash if a builtin fn is declared with positional parameters. (#5444)
Crash discovered by fuzzer.
2025-05-07 22:27:29 +00:00
Richard SmithandJon Ross-Perkins e060342411 Defer building thunks until the end of the enclosing definition. (#5403)
Instead of building the definition of a thunk immediately when we
generate the thunk declaration, wait until we reach the `}` of the
outermost class, interface, etc. -- at the same time when we would parse
the definition of the thunk if it were defined inline.

This fixes issues where we fail to define the thunk because it requires
an enclosing class to be complete, or its definition depends on
something declared later in the enclosing class.

Make the representation of a suspended function scope, and its
constituent suspended components, be move-only, and switch to passing it
around by rvalue reference instead of by value because it's expensive
both to move and especially to copy.

---------

Co-authored-by: Jon Ross-Perkins <jperkins@google.com>
2025-05-07 22:20:39 +00:00
Jon Ross-Perkins 6f32a003d2 Remove needs_substitution logic (#5443)
This is fixing a deduce crash, with regression tests added in
binding_pattern.carbon. In `needs_substitution`, it adds the
`BindSymbolicName` with the compile time bind index corresponding to the
wrong generic scope, which causes a bad result. It appears
`needs_substitution` logic is no longer needed (per zygoloid,
`CheckDeductionIsComplete` handles related issues) so can be removed.

This changes the order of IR in use_assoc_const.carbon but the result
appears equivalent to me.

This was a fuzzer-found crash.
2025-05-07 22:13:33 +00:00
Richard SmithandJon Ross-Perkins c49789d80b Don't use GetCanonicalLocId when determining what instruction an instruction was imported from. (#5418)
The canonical location of the instruction may be an entirely different
instruction, which the instruction in question was not imported from. In
particular, we shouldn't assume that we can use the constant value of an
instruction that the *location* of an imported instruction refers to as
the constant value of the imported instruction.

The only time we should be looking at the `ImportIRInstId` for a `LocId`
is when determining its location in some other file.

Fixes a crash when importing thunks (which can contain instructions
whose location points to an instruction in a differnt IR).

---------

Co-authored-by: Jon Ross-Perkins <jperkins@google.com>
2025-05-05 19:58:30 +00:00
Dana JansensandJon Ross-Perkins aa491d8fd8 Implement non-final impl overlap diagnostics (#5412)
When two non-final impls have the same type structure (neither is a
specialization of the other), it is an error unless they are within a
`match_first` block. For now, we don't have `match_first` implemented,
so it's always an error.

---------

Co-authored-by: Jon Ross-Perkins <jperkins@google.com>
2025-05-05 19:01:41 +00:00