carbon-language/carbon-lang
1
0
Fork 0
mirror of https://github.com/carbon-language/carbon-lang.git synced 2026-09-28 16:24:53 +01:00
Code Issues Packages Projects Releases 10 Wiki Activity
Files
a1d03b1f56d859cd20f45fc77ffbd63dfd1ba3b2
carbon-lang/toolchain/check/testdata/pointer/fail_address_of_value.carbon
T
Richard Smith b138c90c9e Use constant evaluation to determine the identity of types. (#3617) 
Remove the type canonicalization mechanism and instead rely on constant
canonicalization to deduplicate types.

Rename the `Canonicalize*Type` functions to reflect that they're no
longer performing canonicalization. Switch code that creates types due
to semantic checking, rather than due to source syntax, to directly
create type constants through evaluation rather than creating an
instruction and evaluating it to produce a separate constant
representation.

The mapping from `const (const T)` that was previously performed by type
canonicalization is now implemented in expression evaluation instead.

The value `<error>` is now treated as a constant value, with a special
property that an instruction involving `<error>` that could possibly be
constant evaluates to `<error>`. This helps avoid producing follow-on
errors when an error occurs as a subexpression of an expression, such as
a type, that is intended to be constant.
2024-01-19 00:47:37 +00:00

219 lines
10 KiB
Plaintext
Raw Blame History

// 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
fn G() -> i32;
fn H() -> {.a: i32};
fn AddressOfLiteral() {
// CHECK:STDERR: fail_address_of_value.carbon:[[@LINE+3]]:3: ERROR: Cannot take the address of non-reference expression.
// CHECK:STDERR: &0;
// CHECK:STDERR: ^
&0;
// CHECK:STDERR: fail_address_of_value.carbon:[[@LINE+3]]:3: ERROR: Cannot take the address of non-reference expression.
// CHECK:STDERR: &true;
// CHECK:STDERR: ^
&true;
// CHECK:STDERR: fail_address_of_value.carbon:[[@LINE+3]]:3: ERROR: Cannot take the address of non-reference expression.
// CHECK:STDERR: &1.0;
// CHECK:STDERR: ^
&1.0;
// CHECK:STDERR: fail_address_of_value.carbon:[[@LINE+3]]:3: ERROR: Cannot take the address of non-reference expression.
// CHECK:STDERR: &"Hello";
// CHECK:STDERR: ^
&"Hello";
// CHECK:STDERR: fail_address_of_value.carbon:[[@LINE+3]]:3: ERROR: Cannot take the address of non-reference expression.
// CHECK:STDERR: &(1, 2);
// CHECK:STDERR: ^
&(1, 2);
// CHECK:STDERR: fail_address_of_value.carbon:[[@LINE+3]]:3: ERROR: Cannot take the address of non-reference expression.
// CHECK:STDERR: &{.a = 5};
// CHECK:STDERR: ^
&{.a = 5};
}
fn AddressOfOperator() {
// CHECK:STDERR: fail_address_of_value.carbon:[[@LINE+3]]:3: ERROR: Cannot take the address of non-reference expression.
// CHECK:STDERR: &(true and false);
// CHECK:STDERR: ^
&(true and false);
// CHECK:STDERR: fail_address_of_value.carbon:[[@LINE+3]]:3: ERROR: Cannot take the address of a temporary object.
// CHECK:STDERR: &H().a;
// CHECK:STDERR: ^
&H().a;
// CHECK:STDERR: fail_address_of_value.carbon:[[@LINE+3]]:3: ERROR: Cannot take the address of non-reference expression.
// CHECK:STDERR: &(not true);
// CHECK:STDERR: ^
&(not true);
}
fn AddressOfCall() {
// CHECK:STDERR: fail_address_of_value.carbon:[[@LINE+3]]:3: ERROR: Cannot take the address of non-reference expression.
// CHECK:STDERR: &G();
// CHECK:STDERR: ^
&G();
}
fn AddressOfType() {
// CHECK:STDERR: fail_address_of_value.carbon:[[@LINE+3]]:3: ERROR: Cannot take the address of non-reference expression.
// CHECK:STDERR: &i32;
// CHECK:STDERR: ^
&i32;
// CHECK:STDERR: fail_address_of_value.carbon:[[@LINE+3]]:3: ERROR: Cannot take the address of non-reference expression.
// CHECK:STDERR: &(const i32*);
// CHECK:STDERR: ^
&(const i32*);
}
fn AddressOfTupleElementValue() {
// CHECK:STDERR: fail_address_of_value.carbon:[[@LINE+3]]:3: ERROR: Cannot take the address of non-reference expression.
// CHECK:STDERR: &((1, 2)[0]);
// CHECK:STDERR: ^
&((1, 2)[0]);
}
fn AddressOfParam(param: i32) {
// CHECK:STDERR: fail_address_of_value.carbon:[[@LINE+3]]:26: ERROR: Cannot take the address of non-reference expression.
// CHECK:STDERR: var param_addr: i32* = &param;
// CHECK:STDERR: ^
var param_addr: i32* = &param;
}
// CHECK:STDOUT: --- fail_address_of_value.carbon
// CHECK:STDOUT:
// CHECK:STDOUT: constants {
// CHECK:STDOUT: %.1: type = struct_type {.a: i32} [template]
// CHECK:STDOUT: %.2: i32 = int_literal 0 [template]
// CHECK:STDOUT: %.3: type = ptr_type i32 [template]
// CHECK:STDOUT: %.4: i32* = addr_of %.2 [template]
// CHECK:STDOUT: %.5: bool = bool_literal true [template]
// CHECK:STDOUT: %.6: type = ptr_type bool [template]
// CHECK:STDOUT: %.7: bool* = addr_of %.5 [template]
// CHECK:STDOUT: %.8: f64 = real_literal 10e-1 [template]
// CHECK:STDOUT: %.9: type = ptr_type f64 [template]
// CHECK:STDOUT: %.10: f64* = addr_of %.8 [template]
// CHECK:STDOUT: %.11: type = ptr_type String [template]
// CHECK:STDOUT: %.12: String = string_literal "Hello" [template]
// CHECK:STDOUT: %.13: String* = addr_of %.12 [template]
// CHECK:STDOUT: %.14: i32 = int_literal 1 [template]
// CHECK:STDOUT: %.15: i32 = int_literal 2 [template]
// CHECK:STDOUT: %.16: type = tuple_type (i32, i32) [template]
// CHECK:STDOUT: %.17: type = ptr_type (i32, i32) [template]
// CHECK:STDOUT: %.18: i32 = int_literal 5 [template]
// CHECK:STDOUT: %.19: type = ptr_type {.a: i32} [template]
// CHECK:STDOUT: %.20: bool = bool_literal false [template]
// CHECK:STDOUT: %.21: bool* = addr_of %.20 [template]
// CHECK:STDOUT: %.22: type = ptr_type type [template]
// CHECK:STDOUT: %.23: type* = addr_of i32 [template]
// CHECK:STDOUT: %.24: type = const_type i32 [template]
// CHECK:STDOUT: %.25: type = ptr_type const i32 [template]
// CHECK:STDOUT: %.26: type* = addr_of %.25 [template]
// CHECK:STDOUT: %.27: (i32, i32) = tuple_value (%.14, %.15) [template]
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: file {
// CHECK:STDOUT: package: <namespace> = namespace package, {.G = %G, .H = %H, .AddressOfLiteral = %AddressOfLiteral, .AddressOfOperator = %AddressOfOperator, .AddressOfCall = %AddressOfCall, .AddressOfType = %AddressOfType, .AddressOfTupleElementValue = %AddressOfTupleElementValue, .AddressOfParam = %AddressOfParam} [template]
// CHECK:STDOUT: %G: <function> = fn_decl @G [template]
// CHECK:STDOUT: %H: <function> = fn_decl @H [template]
// CHECK:STDOUT: %AddressOfLiteral: <function> = fn_decl @AddressOfLiteral [template]
// CHECK:STDOUT: %AddressOfOperator: <function> = fn_decl @AddressOfOperator [template]
// CHECK:STDOUT: %AddressOfCall: <function> = fn_decl @AddressOfCall [template]
// CHECK:STDOUT: %AddressOfType: <function> = fn_decl @AddressOfType [template]
// CHECK:STDOUT: %AddressOfTupleElementValue: <function> = fn_decl @AddressOfTupleElementValue [template]
// CHECK:STDOUT: %AddressOfParam: <function> = fn_decl @AddressOfParam [template]
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: fn @G() -> i32;
// CHECK:STDOUT:
// CHECK:STDOUT: fn @H() -> {.a: i32};
// CHECK:STDOUT:
// CHECK:STDOUT: fn @AddressOfLiteral() {
// CHECK:STDOUT: !entry:
// CHECK:STDOUT: %.loc15_4: i32 = int_literal 0 [template = constants.%.2]
// CHECK:STDOUT: %.loc15_3: i32* = addr_of %.loc15_4 [template = constants.%.4]
// CHECK:STDOUT: %.loc19_4: bool = bool_literal true [template = constants.%.5]
// CHECK:STDOUT: %.loc19_3: bool* = addr_of %.loc19_4 [template = constants.%.7]
// CHECK:STDOUT: %.loc23_4: f64 = real_literal 10e-1 [template = constants.%.8]
// CHECK:STDOUT: %.loc23_3: f64* = addr_of %.loc23_4 [template = constants.%.10]
// CHECK:STDOUT: %.loc27_4: String = string_literal "Hello" [template = constants.%.12]
// CHECK:STDOUT: %.loc27_3: String* = addr_of %.loc27_4 [template = constants.%.13]
// CHECK:STDOUT: %.loc31_5: i32 = int_literal 1 [template = constants.%.14]
// CHECK:STDOUT: %.loc31_8: i32 = int_literal 2 [template = constants.%.15]
// CHECK:STDOUT: %.loc31_9: (i32, i32) = tuple_literal (%.loc31_5, %.loc31_8)
// CHECK:STDOUT: %.loc31_3: (i32, i32)* = addr_of %.loc31_9
// CHECK:STDOUT: %.loc35_10: i32 = int_literal 5 [template = constants.%.18]
// CHECK:STDOUT: %.loc35_11: {.a: i32} = struct_literal (%.loc35_10)
// CHECK:STDOUT: %.loc35_3: {.a: i32}* = addr_of %.loc35_11
// CHECK:STDOUT: return
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: fn @AddressOfOperator() {
// CHECK:STDOUT: !entry:
// CHECK:STDOUT: %.loc42_5: bool = bool_literal true [template = constants.%.5]
// CHECK:STDOUT: %.loc42_10.1: bool = bool_literal false [template = constants.%.20]
// CHECK:STDOUT: if %.loc42_5 br !and.rhs else br !and.result(%.loc42_10.1)
// CHECK:STDOUT:
// CHECK:STDOUT: !and.rhs:
// CHECK:STDOUT: %.loc42_14: bool = bool_literal false [template = constants.%.20]
// CHECK:STDOUT: br !and.result(%.loc42_14)
// CHECK:STDOUT:
// CHECK:STDOUT: !and.result:
// CHECK:STDOUT: %.loc42_10.2: bool = block_arg !and.result
// CHECK:STDOUT: %.loc42_3: bool* = addr_of %.loc42_10.2
// CHECK:STDOUT: %H.ref: <function> = name_ref H, file.%H [template = file.%H]
// CHECK:STDOUT: %.loc46_5.1: init {.a: i32} = call %H.ref()
// CHECK:STDOUT: %.loc46_5.2: ref {.a: i32} = temporary_storage
// CHECK:STDOUT: %.loc46_5.3: ref {.a: i32} = temporary %.loc46_5.2, %.loc46_5.1
// CHECK:STDOUT: %.loc46_7: ref i32 = struct_access %.loc46_5.3, element0
// CHECK:STDOUT: %.loc46_3: i32* = addr_of %.loc46_7
// CHECK:STDOUT: %.loc50_9: bool = bool_literal true [template = constants.%.5]
// CHECK:STDOUT: %.loc50_5: bool = not %.loc50_9 [template = constants.%.20]
// CHECK:STDOUT: %.loc50_3: bool* = addr_of %.loc50_5 [template = constants.%.21]
// CHECK:STDOUT: return
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: fn @AddressOfCall() {
// CHECK:STDOUT: !entry:
// CHECK:STDOUT: %G.ref: <function> = name_ref G, file.%G [template = file.%G]
// CHECK:STDOUT: %.loc57_5: init i32 = call %G.ref()
// CHECK:STDOUT: %.loc57_3: i32* = addr_of %.loc57_5
// CHECK:STDOUT: return
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: fn @AddressOfType() {
// CHECK:STDOUT: !entry:
// CHECK:STDOUT: %.loc64: type* = addr_of i32 [template = constants.%.23]
// CHECK:STDOUT: %.loc68_5: type = const_type i32 [template = constants.%.24]
// CHECK:STDOUT: %.loc68_14: type = ptr_type const i32 [template = constants.%.25]
// CHECK:STDOUT: %.loc68_3: type* = addr_of %.loc68_14 [template = constants.%.26]
// CHECK:STDOUT: return
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: fn @AddressOfTupleElementValue() {
// CHECK:STDOUT: !entry:
// CHECK:STDOUT: %.loc75_6: i32 = int_literal 1 [template = constants.%.14]
// CHECK:STDOUT: %.loc75_9: i32 = int_literal 2 [template = constants.%.15]
// CHECK:STDOUT: %.loc75_10.1: (i32, i32) = tuple_literal (%.loc75_6, %.loc75_9)
// CHECK:STDOUT: %.loc75_12: i32 = int_literal 0 [template = constants.%.2]
// CHECK:STDOUT: %.loc75_10.2: (i32, i32) = tuple_value (%.loc75_6, %.loc75_9) [template = constants.%.27]
// CHECK:STDOUT: %.loc75_10.3: (i32, i32) = converted %.loc75_10.1, %.loc75_10.2 [template = constants.%.27]
// CHECK:STDOUT: %.loc75_13: i32 = tuple_index %.loc75_10.3, %.loc75_12
// CHECK:STDOUT: %.loc75_3: i32* = addr_of %.loc75_13
// CHECK:STDOUT: return
// CHECK:STDOUT: }
// CHECK:STDOUT:
// CHECK:STDOUT: fn @AddressOfParam(%param: i32) {
// CHECK:STDOUT: !entry:
// CHECK:STDOUT: %.loc82_22: type = ptr_type i32 [template = constants.%.3]
// CHECK:STDOUT: %param_addr.var: ref i32* = var param_addr
// CHECK:STDOUT: %param_addr: ref i32* = bind_name param_addr, %param_addr.var
// CHECK:STDOUT: %param.ref: i32 = name_ref param, %param
// CHECK:STDOUT: %.loc82_26: i32* = addr_of %param.ref
// CHECK:STDOUT: assign %param_addr.var, %.loc82_26
// CHECK:STDOUT: return
// CHECK:STDOUT: }
// CHECK:STDOUT:
Reference in New Issue View Git Blame Copy Permalink