mirror of
https://github.com/carbon-language/carbon-lang.git
synced 2026-09-24 21:10:12 +01:00
Jon Ross-PerkinsandGeoff Romer
7209ad7c9f
Although this focused on `Destroy` support, some choices here around `implicit_type_impls` are because copy/move will likely follow a similar approach. I'm trying not to predict too much about how we'll structure those, but I'm putting `Destroy` impl logic in a file that could perhaps be shared with those. They'd likely be interested in similar things, e.g. traversing members of types (particularly class, struct literal, tuple literal). At present this sets the destroy function as `no_op` which is consistent with current logic, but has a TODO to correctly define. Constant importing for functions changes slightly due to some issues I was having with `GetFunctionType`. zygoloid suggested this approach to avoid `EvalInst` logic. Adds a flag for controlling whether to generating these impls. While this does generation for `class`, as noted above this'll also need to be done for tuples and struct literals, which would leave the `none.carbon` min_prelude unable to use any types. Note if destruction *would* occur, it'll still look up `Core.Destroy` for that and fail, but that's already true of any test using `none.carbon`. I'm trying to use the flag to see if we can keep `none.carbon` working mostly-consistently. I'd tried separating out the flag to #5852, but that got a lot of pushback over whether the behavior was appropriate. I'm hoping that the interactions here make it clearer why the particular approach -- the goal is not to enable advanced testing, or create some new end-user behavior that we really support, it's just to keep no-prelude tests functional. The main question raised there was why not just keep generating `impl T as Core.Destroy` if `fn destroy` is present -- but I think here it should be apparent that would require additional complexity, as the generation of `impl T as Core.Destroy` is not currently conditioned based on the implementation of `fn destroy`. I'd rather add complexity to this flag only if it's enabling interesting test functionality. --------- Co-authored-by: Geoff Romer <gromer@google.com>
67 lines
2.9 KiB
C++
67 lines
2.9 KiB
C++
// 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
|
|
|
|
#ifndef CARBON_TOOLCHAIN_CHECK_PATTERN_H_
|
|
#define CARBON_TOOLCHAIN_CHECK_PATTERN_H_
|
|
|
|
#include "toolchain/check/context.h"
|
|
#include "toolchain/sem_ir/ids.h"
|
|
|
|
namespace Carbon::Check {
|
|
|
|
// Marks the start of a region of insts in a pattern context that might
|
|
// represent an expression or a pattern. Typically this is called when
|
|
// handling a parse node that can immediately precede a subpattern (such
|
|
// as `let` or a `,` in a pattern list), and the handler for the subpattern
|
|
// node makes the matching `EndSubpatternAs*` call.
|
|
auto BeginSubpattern(Context& context) -> void;
|
|
|
|
// Ends a region started by BeginSubpattern (in stack order), treating it as
|
|
// an expression with the given result, and returns the ID of the region. The
|
|
// region will not yet have any control-flow edges into or out of it.
|
|
auto EndSubpatternAsExpr(Context& context, SemIR::InstId result_id)
|
|
-> SemIR::ExprRegionId;
|
|
|
|
// Ends a region started by BeginSubpattern (in stack order), asserting that
|
|
// it had no expression content.
|
|
auto EndSubpatternAsNonExpr(Context& context) -> void;
|
|
|
|
// Information about a created binding pattern.
|
|
struct BindingPatternInfo {
|
|
SemIR::InstId pattern_id;
|
|
SemIR::InstId bind_id;
|
|
};
|
|
|
|
// TODO: Add EndSubpatternAsPattern, when needed.
|
|
|
|
// Creates a binding pattern. Returns the binding pattern and the bind name
|
|
// instruction.
|
|
auto AddBindingPattern(Context& context, SemIR::LocId name_loc,
|
|
SemIR::NameId name_id, SemIR::TypeId type_id,
|
|
SemIR::ExprRegionId type_region_id, bool is_generic,
|
|
bool is_template) -> BindingPatternInfo;
|
|
|
|
// Creates storage for `var` patterns nested within the given pattern at the
|
|
// current location in the output SemIR. For a `returned var`, this
|
|
// reuses the function's return slot when present.
|
|
auto AddPatternVarStorage(Context& context, SemIR::InstBlockId pattern_block_id,
|
|
bool is_returned_var) -> void;
|
|
|
|
// Adds a `self` parameter pattern with the specified type information. This
|
|
// only sets up the binding pattern and type; callers are expected to add the
|
|
// returned instruction to appropriate blocks. This is used when generating
|
|
// functions, rather than processing a user-authored `self: Self`.
|
|
auto AddSelfParamPattern(Context& context, SemIR::LocId loc_id,
|
|
SemIR::ExprRegionId type_expr_region_id,
|
|
SemIR::TypeId type_id) -> SemIR::InstId;
|
|
|
|
// As the above, but for `addr self: Self*`.
|
|
auto AddAddrSelfParamPattern(Context& context, SemIR::LocId loc_id,
|
|
SemIR::ExprRegionId type_expr_region_id,
|
|
SemIR::TypeInstId type_inst_id) -> SemIR::InstId;
|
|
|
|
} // namespace Carbon::Check
|
|
|
|
#endif // CARBON_TOOLCHAIN_CHECK_PATTERN_H_
|