});
}
+const char *
+ConstChecker::ctx_to_str (ConstGenericCtx ctx)
+{
+ switch (ctx)
+ {
+ case ConstGenericCtx::Function:
+ return "function";
+ case ConstGenericCtx::TypeAlias:
+ return "type alias";
+ case ConstGenericCtx::Struct:
+ return "struct";
+ case ConstGenericCtx::Enum:
+ return "enum";
+ case ConstGenericCtx::Union:
+ return "union";
+ case ConstGenericCtx::Trait:
+ return "trait";
+ case ConstGenericCtx::Impl:
+ return "impl";
+ default:
+ gcc_unreachable ();
+ }
+}
+
+bool
+ConstChecker::ctx_allows_default (ConstGenericCtx ctx)
+{
+ switch (ctx)
+ {
+ case ConstGenericCtx::TypeAlias:
+ case ConstGenericCtx::Struct:
+ case ConstGenericCtx::Enum:
+ case ConstGenericCtx::Trait:
+ return true;
+ default:
+ return false;
+ }
+}
+
+void
+ConstChecker::check_default_const_generics (
+ std::vector<std::unique_ptr<GenericParam>> ¶ms, ConstGenericCtx context)
+{
+ if (ctx_allows_default (context))
+ return;
+
+ for (auto ¶m : params)
+ {
+ if (param->get_kind () == GenericParam::GenericKind::CONST)
+ {
+ auto const_param = static_cast<ConstGenericParam *> (param.get ());
+ if (const_param->has_default_expression ())
+ rust_error_at (
+ param->get_locus (),
+ "default values for const generic parameters are not "
+ "allowed in %qs items",
+ ctx_to_str (context));
+ }
+ }
+}
+
void
ConstChecker::visit (Lifetime &lifetime)
{}
if (const_fn)
const_context.enter (function.get_mappings ().get_hirid ());
+ check_default_const_generics (function.get_generic_params (),
+ ConstGenericCtx::Function);
+
for (auto ¶m : function.get_function_params ())
param.get_type ()->accept_vis (*this);
void
ConstChecker::visit (TypeAlias &type_alias)
-{}
+{
+ check_default_const_generics (type_alias.get_generic_params (),
+ ConstGenericCtx::TypeAlias);
+}
void
ConstChecker::visit (StructStruct &struct_item)
-{}
+{
+ check_default_const_generics (struct_item.get_generic_params (),
+ ConstGenericCtx::Struct);
+}
void
ConstChecker::visit (TupleStruct &tuple_struct)
-{}
+{
+ check_default_const_generics (tuple_struct.get_generic_params (),
+ ConstGenericCtx::Struct);
+}
void
-ConstChecker::visit (EnumItem &item)
+ConstChecker::visit (EnumItem &enum_item)
{}
void
void
ConstChecker::visit (Enum &enum_item)
-{}
+{
+ check_default_const_generics (enum_item.get_generic_params (),
+ ConstGenericCtx::Enum);
+}
void
ConstChecker::visit (Union &union_item)
-{}
+{
+ check_default_const_generics (union_item.get_generic_params (),
+ ConstGenericCtx::Union);
+}
void
ConstChecker::visit (ConstantItem &const_item)
void
ConstChecker::visit (Trait &trait)
{
+ check_default_const_generics (trait.get_generic_params (),
+ ConstGenericCtx::Trait);
+
for (auto &item : trait.get_trait_items ())
item->accept_vis (*this);
}
void
ConstChecker::visit (ImplBlock &impl)
{
+ check_default_const_generics (impl.get_generic_params (),
+ ConstGenericCtx::Impl);
+
for (auto &item : impl.get_impl_items ())
item->accept_vis (*this);
}
*/
void check_function_call (HirId fn_id, Location locus);
+ /* All possible const contexts */
+ enum class ConstGenericCtx
+ {
+ Function,
+ TypeAlias,
+ Struct,
+ Enum,
+ Union,
+ Trait,
+ Impl
+ };
+
+ /* Get the string representation of a const context */
+ const char *ctx_to_str (ConstGenericCtx ctx);
+
+ /* Check if a const context allows default values */
+ bool ctx_allows_default (ConstGenericCtx ctx);
+
+ /**
+ * Check that const generic parameters only contains defaults in allowed
+ * contexts
+ */
+ void check_default_const_generics (
+ std::vector<std::unique_ptr<GenericParam>> ¶m, ConstGenericCtx context);
+
StackedContexts<HirId> const_context;
Resolver::Resolver &resolver;
Analysis::Mappings &mappings;