break;
}
default:
- gcc_unreachable ();
+ rust_unreachable ();
}
}
push (Rust::Token::make (RIGHT_SQUARE, UNDEF_LOCATION));
}
break;
case GenericArg::Kind::Error:
- gcc_unreachable ();
+ rust_unreachable ();
}
}
else if (value == "true")
push (Rust::Token::make (TRUE_LITERAL, locus));
else
- gcc_unreachable (); // Not a boolean
+ rust_unreachable (); // Not a boolean
break;
}
case Literal::LitType::ERROR:
- gcc_unreachable ();
+ rust_unreachable ();
break;
}
}
TokenCollector::visit (StructExprStructBase &)
{
// FIXME: Implement this node
- gcc_unreachable ();
+ rust_unreachable ();
}
void
case CURLY:
return {LEFT_CURLY, RIGHT_CURLY};
default:
- gcc_unreachable ();
+ rust_unreachable ();
}
}
previous = nullptr;
break;
default:
- gcc_unreachable ();
+ rust_unreachable ();
}
}
}
default:
return "ERROR-MARK-STRING (delims)";
}
- gcc_unreachable ();
+ rust_unreachable ();
}
std::string
case INNER:
return "inner attributes";
default:
- gcc_unreachable ();
+ rust_unreachable ();
return "";
}
}
case PUB_IN_PATH:
return std::string ("pub(in ") + in_path.as_string () + std::string (")");
default:
- gcc_unreachable ();
+ rust_unreachable ();
}
}
// some kind of error
return "ERROR-PATH";
}
- gcc_unreachable ();
+ rust_unreachable ();
}
std::string
return type == nullptr;
}
- gcc_unreachable ();
+ rust_unreachable ();
return true;
}
return "Type: " + type->as_string ();
}
- gcc_unreachable ();
+ rust_unreachable ();
return "";
}
};
/**
* Default function to use as an associated transcriber. This function should
- * never be called, hence the gcc_unreachable().
+ * never be called, hence the rust_unreachable().
* If this function is used, then the macro is not builtin and the compiler
* should make use of the actual rules. If the macro is builtin, then another
* associated transcriber should be used
*/
static Fragment dummy_builtin (Location, MacroInvocData &)
{
- gcc_unreachable ();
+ rust_unreachable ();
return Fragment::create_error ();
}
case Kind::Either:
break;
case Kind::Error:
- gcc_unreachable ();
+ rust_unreachable ();
}
}
switch (get_kind ())
{
case Kind::Error:
- gcc_unreachable ();
+ rust_unreachable ();
case Kind::Either:
return "Ambiguous: " + path.as_string ();
case Kind::Const:
else /* TuplePatternItemType::RANGED */
{
// FIXME
- gcc_unreachable ();
+ rust_unreachable ();
}
}
else
{
// FIXME: There are other cases, but it better not be a Tuple
- gcc_unreachable ();
+ rust_unreachable ();
}
}
break;
case HIR::Expr::ExprType::Path: {
// FIXME
- gcc_unreachable ();
+ rust_unreachable ();
}
break;
default:
- gcc_unreachable ();
+ rust_unreachable ();
}
}
else
{
// FIXME: match on other types of expressions not yet implemented.
- gcc_unreachable ();
+ rust_unreachable ();
}
// setup the end label so the cases can exit properly
else
{
// FIXME error message?
- gcc_unreachable ();
+ rust_unreachable ();
return error_mark_node;
}
break;
default:
- gcc_unreachable ();
+ rust_unreachable ();
break;
}
rust_assert (overflow_builtin != error_mark_node);
{
case HIR::TupleStructItems::RANGE: {
// TODO
- gcc_unreachable ();
+ rust_unreachable ();
}
break;
{
case HIR::StructPatternField::ItemType::TUPLE_PAT: {
// TODO
- gcc_unreachable ();
+ rust_unreachable ();
}
break;
case HIR::StructPatternField::ItemType::IDENT_PAT: {
// TODO
- gcc_unreachable ();
+ rust_unreachable ();
}
break;
return;
}
default: {
- gcc_unreachable ();
+ rust_unreachable ();
}
}
}
if (ce->index == field)
return ce;
- gcc_unreachable ();
+ rust_unreachable ();
return NULL;
}
/* We can't do anything with other tree codes, so use
VERIFY_CONSTANT to complain and fail. */
VERIFY_CONSTANT (ary);
- gcc_unreachable ();
+ rust_unreachable ();
}
bool found;
break;
default:
- gcc_unreachable ();
+ rust_unreachable ();
}
return false;
}
if (TREE_CODE (probe) == ARRAY_REF)
{
// TODO
- gcc_unreachable ();
+ rust_unreachable ();
// elt = eval_and_check_array_index (ctx, probe, false,
// non_constant_p, overflow_p);
if (*non_constant_p)
{
// return cxx_eval_internal_function (ctx, t, lval,
// non_constant_p, overflow_p);
- gcc_unreachable ();
+ rust_unreachable ();
return error_mark_node;
}
// goto found;
//
// default:
-// gcc_unreachable ();
+// rust_unreachable ();
// }
// found:
//
return 0;
}
default:
- gcc_unreachable ();
+ rust_unreachable ();
}
}
else if (VECTOR_TYPE_P (type))
nelts = size_int (TYPE_VECTOR_SUBPARTS (type));
else
- gcc_unreachable ();
+ rust_unreachable ();
/* For VLAs, the number of elements won't be an integer constant. */
nelts
}
if (fld_seen)
return fold_convert (TREE_TYPE (t), retval);
- gcc_unreachable ();
+ rust_unreachable ();
return error_mark_node;
}
count = -1;
break;
default:
- gcc_unreachable ();
+ rust_unreachable ();
}
auto_vec<tree, 10> save_exprs;
new_ctx.save_exprs = &save_exprs;
default:
sorry ("unexpected AST of kind %s", get_tree_code_name (TREE_CODE (t)));
- gcc_unreachable ();
+ rust_unreachable ();
return false;
}
#undef RECUR
return "";
}
- gcc_unreachable ();
+ rust_unreachable ();
}
// Add an underscore-terminated base62 integer to the mangling string.
return ty_prefix;
// FIXME: We need to fetch more type prefixes
- gcc_unreachable ();
+ rust_unreachable ();
}
static std::string
v0_add_identifier (mangled, crate_name);
v0_add_disambiguator (mangled, 62);
- gcc_unreachable ();
+ rust_unreachable ();
}
std::string
case Mangler::MangleVersion::V0:
return v0_mangle_item (ty, path);
default:
- gcc_unreachable ();
+ rust_unreachable ();
}
}
type);
break;
default:
- gcc_unreachable ();
+ rust_unreachable ();
}
}
/* Don't load the value if this is an implicit dereference, or if
type);
break;
default:
- gcc_unreachable ();
+ rust_unreachable ();
}
}
else if (is_volatile && TREE_ADDRESSABLE (type))
type);
break;
default:
- gcc_unreachable ();
+ rust_unreachable ();
}
}
if (is_reference || !is_volatile || !is_complete
expr, type);
break;
default:
- gcc_unreachable ();
+ rust_unreachable ();
}
break;
else if (TREE_CODE (type) == METHOD_TYPE)
return rs_type_quals (class_of_this_parm (type));
else
- gcc_unreachable ();
+ rust_unreachable ();
}
// forked from gcc/cp/pt.cc find_parameter_pack_data
case VOID_CST:
/* There's only a single VOID_CST node, so we should never reach
here. */
- gcc_unreachable ();
+ rust_unreachable ();
case INTEGER_CST:
return tree_int_cst_equal (t1, t2);
return same_type_p (t1, t2);
default:
- gcc_unreachable ();
+ rust_unreachable ();
}
/* We can get here with --disable-checking. */
return fold_offsetof (t, type);
default:
- gcc_unreachable ();
+ rust_unreachable ();
}
if (!POINTER_TYPE_P (type))
break;
default:
- gcc_unreachable ();
+ rust_unreachable ();
}
}
else if (strcmp (n, "_M_column") == 0)
val = build_int_cst (TREE_TYPE (field), LOCATION_COLUMN (loc));
else
- gcc_unreachable ();
+ rust_unreachable ();
CONSTRUCTOR_APPEND_ELT (v, field, val);
}
error_at (loc, "lvalue required in %<asm%> statement");
break;
default:
- gcc_unreachable ();
+ rust_unreachable ();
}
}
/* Nothing is deletable. Everything is insertable. */
static bool is_deleted (value_type) { return false; }
- static void mark_deleted (value_type) { gcc_unreachable (); }
+ static void mark_deleted (value_type) { rust_unreachable (); }
};
// forked from gcc/cp/cp-tree.h lang_decl_selector
/* Nothing is deletable. Everything is insertable. */
inline static bool is_deleted (value_type) { return false; }
- inline static void mark_deleted (value_type) { gcc_unreachable (); }
+ inline static void mark_deleted (value_type) { rust_unreachable (); }
};
// forked from gcc/cp/cp-tree.h
return result;
}
default:
- gcc_unreachable ();
+ rust_unreachable ();
return false;
}
}
vis_item = static_cast<HIR::ConstantItem *> (item.get ());
break;
default:
- gcc_unreachable ();
+ rust_unreachable ();
return;
}
vis_item->accept_vis (*this);
case ConstGenericCtx::Impl:
return "impl";
default:
- gcc_unreachable ();
+ rust_unreachable ();
}
}
return Feature (Feature::Name::EXTERN_TYPES, Feature::State::ACTIVE,
"extern_types", "1.23.0", 43467, tl::nullopt, "");
default:
- gcc_unreachable ();
+ rust_unreachable ();
}
}
case AST::AttrInput::LITERAL:
case AST::AttrInput::META_ITEM:
case AST::AttrInput::MACRO:
- gcc_unreachable ();
+ rust_unreachable ();
break;
}
result.push_back (node.take_item ());
break;
default:
- gcc_unreachable ();
+ rust_unreachable ();
}
}
}
result.push_back (node.take_item ());
break;
default:
- gcc_unreachable ();
+ rust_unreachable ();
}
}
}
result.push_back (node.take_stmt ());
break;
default:
- gcc_unreachable ();
+ rust_unreachable ();
}
}
}
}
break;
default:
- gcc_unreachable ();
+ rust_unreachable ();
}
return true;
res = match_n_matches (parser, rep, match_amount, 0, 1);
break;
default:
- gcc_unreachable ();
+ rust_unreachable ();
}
rust_debug_loc (rep.get_match_locus (), "%s matched %lu times",
case MacroExpander::ContextType::EXPR:
return transcribe_expression (parser);
default:
- gcc_unreachable ();
+ rust_unreachable ();
}
}
// Extern crate path is not available.
// FIXME: Emit error
rust_error_at (UNDEF_LOCATION, "Cannot find requested proc macro crate");
- gcc_unreachable ();
+ rust_unreachable ();
}
auto macros = load_macros (path->second);
macro.payload.bang);
break;
default:
- gcc_unreachable ();
+ rust_unreachable ();
}
}
}
case ContextType::TYPE:
case ContextType::EXPR:
default:
- gcc_unreachable ();
+ rust_unreachable ();
}
if (parser.has_errors ())
current_map.emplace (fragment.fragment_ident,
MatchedFragmentContainer::metavar (fragment));
else
- gcc_unreachable ();
+ rust_unreachable ();
}
/**
std::string get_filename () const
{
// FIXME
- gcc_unreachable ();
+ rust_unreachable ();
return "FIXME";
}
std::string get_filename () const
{
// FIXME
- gcc_unreachable ();
+ rust_unreachable ();
return "FIXME";
}
}
}
- gcc_unreachable ();
+ rust_unreachable ();
}
std::vector<std::unique_ptr<AST::Token>>
std::string get_filename () const
{
// FIXME
- gcc_unreachable ();
+ rust_unreachable ();
return "FIXME";
}
#else
rust_sorry_at (UNDEF_LOCATION,
"Procedural macros are not yet supported on windows host");
- gcc_unreachable ();
+ rust_unreachable ();
#endif
}
const ProcMacro::ProcmacroArray *array = load_macros_array (path);
// Did not load the proc macro
if (array == nullptr)
- gcc_unreachable ();
+ rust_unreachable ();
rust_debug ("Found %lu procedural macros", array->length);
break;
}
default:
- gcc_unreachable ();
+ rust_unreachable ();
}
}
type = HIR::Literal::LitType::BOOL;
break;
case AST::Literal::LitType::ERROR:
- gcc_unreachable ();
+ rust_unreachable ();
break;
}
op = ArithmeticOrLogicalOperator::RIGHT_SHIFT;
break;
default:
- gcc_unreachable ();
+ rust_unreachable ();
}
HIR::Expr *asignee_expr
{
case AST::TupleStructItems::RANGE: {
// TODO
- gcc_unreachable ();
+ rust_unreachable ();
}
break;
{
case AST::StructPatternField::ItemType::TUPLE_PAT: {
// TODO
- gcc_unreachable ();
+ rust_unreachable ();
}
break;
kind = HIR::MaybeNamedParam::ParamKind::WILDCARD;
break;
default:
- gcc_unreachable ();
+ rust_unreachable ();
}
HIR::Type *param_type
operator_str = ">>";
break;
default:
- gcc_unreachable ();
+ rust_unreachable ();
break;
}
default:
return "ERROR-MARK-STRING (delims)";
}
- gcc_unreachable ();
+ rust_unreachable ();
}
std::string
return std::string ("pub(in ") + path.get_mappings ().as_string ()
+ std::string (")");
default:
- gcc_unreachable ();
+ rust_unreachable ();
}
}
// some kind of error
return "ERROR-PATH";
}
- gcc_unreachable ();
+ rust_unreachable ();
}
std::string
operator_str = ">>";
break;
default:
- gcc_unreachable ();
+ rust_unreachable ();
break;
}
operator_str = ">>";
break;
default:
- gcc_unreachable ();
+ rust_unreachable ();
break;
}
}
else
{
- gcc_unreachable ();
+ rust_unreachable ();
}
str.shrink_to_fit ();
}
else
{
- gcc_unreachable ();
+ rust_unreachable ();
}
str.shrink_to_fit ();
#undef RS_TOKEN_KEYWORD
#undef RS_TOKEN
default:
- gcc_unreachable ();
+ rust_unreachable ();
}
}
#undef RS_TOKEN_KEYWORD
#undef RS_TOKEN
default:
- gcc_unreachable ();
+ rust_unreachable ();
}
}
static const std::string str (str_ptr); \
return str; \
} \
- gcc_unreachable ();
+ rust_unreachable ();
#define RS_TOKEN(a, b)
RS_TOKEN_LIST
#undef RS_TOKEN_KEYWORD
#undef RS_TOKEN
default:
- gcc_unreachable ();
+ rust_unreachable ();
}
}
// test prevent error
return AST::SimplePathSegment::create_error ();
}
- gcc_unreachable ();
+ rust_unreachable ();
/*rust_error_at(
t->get_locus(), "invalid token '%s' in simple path segment",
t->get_token_description());*/
// test prevent error
return AST::PathIdentSegment::create_error ();
}
- gcc_unreachable ();
+ rust_unreachable ();
// not necessarily an error
}
skip_after_end_attribute ();
return nullptr;
}
- gcc_unreachable ();
+ rust_unreachable ();
// TODO: find out how to stop gcc error on "no return value"
}
lexer.skip_token (1); // TODO: is this right thing to do?
return nullptr;
}
- gcc_unreachable ();
+ rust_unreachable ();
default:
add_error (Error (t->get_locus (),
"unrecognised token %qs for item in inherent impl",
lexer.skip_token (1); // TODO: is this right thing to do?
return nullptr;
}
- gcc_unreachable ();
+ rust_unreachable ();
default:
break;
}
new AST::TypePathSegment (std::move (ident_segment),
has_separating_scope_resolution, locus));
}
- gcc_unreachable ();
+ rust_unreachable ();
}
// Parses a function call representation inside a type path.
new AST::ReferenceType (false, parse_reference_type_inner (locus),
locus));
default:
- gcc_unreachable ();
+ rust_unreachable ();
}
}
return std::unique_ptr<AST::PathInExpression> (
new AST::PathInExpression (std::move (path)));
}
- gcc_unreachable ();
+ rust_unreachable ();
}
// Handling of expresions that do not start with a path for `null_denotation`.
return LBP_R_SHIFT;
default:
// WTF? should not happen, this is an error
- gcc_unreachable ();
+ rust_unreachable ();
return LBP_PLUS;
}
return LBP_SMALLER_EQUAL;
default:
// WTF? should not happen, this is an error
- gcc_unreachable ();
+ rust_unreachable ();
return LBP_EQUAL;
}
return LBP_R_SHIFT;
default:
// WTF? should not happen, this is an error
- gcc_unreachable ();
+ rust_unreachable ();
return LBP_PLUS;
}
delim_id = LEFT_CURLY;
break;
default:
- gcc_unreachable ();
+ rust_unreachable ();
break;
}
if (contains (allowed_toks, delim_id))
}
else
{
- gcc_unreachable ();
+ rust_unreachable ();
}
}
return resolved_node_id;
}
else
{
- gcc_unreachable ();
+ rust_unreachable ();
}
}
return resolved_node_id;
{
case AST::TupleStructItems::RANGE: {
// TODO
- gcc_unreachable ();
+ rust_unreachable ();
}
break;
{
case AST::StructPatternField::ItemType::TUPLE_PAT: {
// TODO
- gcc_unreachable ();
+ rust_unreachable ();
}
break;
}
else
{
- gcc_unreachable ();
+ rust_unreachable ();
}
}
// constant or an ambiguous const generic?
// TODO: At that point, will all generics have been
// disambiguated? Can we thus canonical resolve types and
- // const and `gcc_unreachable` on ambiguous types?
+ // const and `rust_unreachable` on ambiguous types?
// This is probably fine as we just want to canonicalize
// types, right?
if (generic.get_kind () == AST::GenericArg::Kind::Type)
ResolveTypeToCanonicalPath::visit (AST::TraitObjectType &)
{
// FIXME is this actually allowed? dyn A+B
- gcc_unreachable ();
+ rust_unreachable ();
}
ResolveTypeToCanonicalPath::ResolveTypeToCanonicalPath ()
ResolveType::go (arg.get_type ().get ());
break;
default:
- gcc_unreachable ();
+ rust_unreachable ();
}
}
void
case NegationOperator::NOT:
return TRUTH_NOT_EXPR;
default:
- gcc_unreachable ();
+ rust_unreachable ();
}
}
case ArithmeticOrLogicalOperator::RIGHT_SHIFT:
return RSHIFT_EXPR;
default:
- gcc_unreachable ();
+ rust_unreachable ();
}
}
case ComparisonOperator::LESS_OR_EQUAL:
return LE_EXPR;
default:
- gcc_unreachable ();
+ rust_unreachable ();
}
}
case LazyBooleanOperator::LOGICAL_AND:
return TRUTH_ANDIF_EXPR;
default:
- gcc_unreachable ();
+ rust_unreachable ();
}
}
builtin_ctx.lookup_simple_builtin ("mul_overflow", &builtin);
break;
default:
- gcc_unreachable ();
+ rust_unreachable ();
break;
};
}
default:
- gcc_unreachable ();
+ rust_unreachable ();
}
- gcc_unreachable ();
+ rust_unreachable ();
}
// Convert EXPR_TREE to TYPE_TREE. Sometimes the same unnamed Rust type
expr_tree);
}
- gcc_unreachable ();
+ rust_unreachable ();
}
// Make a global variable.
return (unsignedp ? int_n_trees[i].unsigned_type
: int_n_trees[i].signed_type);
- /* gcc_unreachable */
+ /* rust_unreachable */
return NULL;
}
grs_langhook_global_bindings_p (void)
{
// return current_function_decl == NULL_TREE;
- // gcc_unreachable();
+ // rust_unreachable();
// return true;
return false;
}
static tree
grs_langhook_pushdecl (tree decl ATTRIBUTE_UNUSED)
{
- gcc_unreachable ();
+ rust_unreachable ();
return NULL;
}
static tree
grs_langhook_getdecls (void)
{
- // gcc_unreachable();
+ // rust_unreachable();
return NULL;
}
break;
}
- gcc_unreachable ();
+ rust_unreachable ();
}
/* FIXME: This is a hack to preserve trees that we create from the
// When using gcc, rust_assert is just gcc_assert.
#define rust_assert(EXPR) gcc_assert (EXPR)
-// When using gcc, rust_unreachable is just gcc_unreachable.
-#define rust_unreachable() gcc_unreachable ()
+/**
+ * rust_unreachable is just a fancy abort which causes an internal compiler
+ * error. This macro is not equivalent to `__builtin_unreachable` and does not
+ * indicate optimizations for the compiler
+ */
+#define rust_unreachable() (fancy_abort (__FILE__, __LINE__, __FUNCTION__))
extern void
rust_preserve_from_gc (tree t);
case AdjustmentType::UNSIZE:
return "UNSIZE";
}
- gcc_unreachable ();
+ rust_unreachable ();
return "";
}
case TraitItemReference::TraitItemType::ERROR:
default:
- gcc_unreachable ();
+ rust_unreachable ();
break;
}
case TraitItemReference::TraitItemType::ERROR:
default:
- gcc_unreachable ();
+ rust_unreachable ();
break;
}
return get_error ();
}
- gcc_unreachable ();
+ rust_unreachable ();
return get_error ();
}
break;
default:
- gcc_unreachable ();
+ rust_unreachable ();
break;
}
== TyTy::InferType::INTEGRAL));
}
- gcc_unreachable ();
+ rust_unreachable ();
return false;
}
void visit (HIR::AsyncBlockExpr &) override {}
// don't need to implement these see rust-hir-type-check-struct-field.h
- void visit (HIR::StructExprFieldIdentifier &) override { gcc_unreachable (); }
- void visit (HIR::StructExprFieldIndexValue &) override { gcc_unreachable (); }
+ void visit (HIR::StructExprFieldIdentifier &) override
+ {
+ rust_unreachable ();
+ }
+ void visit (HIR::StructExprFieldIndexValue &) override
+ {
+ rust_unreachable ();
+ }
void visit (HIR::StructExprFieldIdentifierValue &) override
{
- gcc_unreachable ();
+ rust_unreachable ();
}
protected:
break;
default:
- gcc_unreachable ();
+ rust_unreachable ();
return;
}
}
{
case HIR::TupleStructItems::RANGE: {
// TODO
- gcc_unreachable ();
+ rust_unreachable ();
}
break;
{
case HIR::StructPatternField::ItemType::TUPLE_PAT: {
// TODO
- gcc_unreachable ();
+ rust_unreachable ();
}
break;
// = *static_cast<HIR::TuplePatternItemsRanged *> (
// pattern.get_items ().get ());
// TODO
- gcc_unreachable ();
+ rust_unreachable ();
}
break;
}
// this seems like it should not be part of this visitor
void visit (HIR::TypePathSegmentFunction &segment) override
{
- gcc_unreachable ();
+ rust_unreachable ();
}
// nothing to do for these
break;
default:
- gcc_unreachable ();
+ rust_unreachable ();
return nullptr;
}
}
void visit (TyTy::ProjectionType &type) override;
// nothing to do for these
- void visit (TyTy::InferType &) override { gcc_unreachable (); }
- void visit (TyTy::TupleType &) override { gcc_unreachable (); }
- void visit (TyTy::FnPtr &) override { gcc_unreachable (); }
- void visit (TyTy::ArrayType &) override { gcc_unreachable (); }
- void visit (TyTy::SliceType &) override { gcc_unreachable (); }
- void visit (TyTy::BoolType &) override { gcc_unreachable (); }
- void visit (TyTy::IntType &) override { gcc_unreachable (); }
- void visit (TyTy::UintType &) override { gcc_unreachable (); }
- void visit (TyTy::FloatType &) override { gcc_unreachable (); }
- void visit (TyTy::USizeType &) override { gcc_unreachable (); }
- void visit (TyTy::ISizeType &) override { gcc_unreachable (); }
- void visit (TyTy::ErrorType &) override { gcc_unreachable (); }
- void visit (TyTy::CharType &) override { gcc_unreachable (); }
- void visit (TyTy::ReferenceType &) override { gcc_unreachable (); }
- void visit (TyTy::PointerType &) override { gcc_unreachable (); }
- void visit (TyTy::ParamType &) override { gcc_unreachable (); }
- void visit (TyTy::StrType &) override { gcc_unreachable (); }
- void visit (TyTy::NeverType &) override { gcc_unreachable (); }
- void visit (TyTy::DynamicObjectType &) override { gcc_unreachable (); }
- void visit (TyTy::ClosureType &) override { gcc_unreachable (); }
+ void visit (TyTy::InferType &) override { rust_unreachable (); }
+ void visit (TyTy::TupleType &) override { rust_unreachable (); }
+ void visit (TyTy::FnPtr &) override { rust_unreachable (); }
+ void visit (TyTy::ArrayType &) override { rust_unreachable (); }
+ void visit (TyTy::SliceType &) override { rust_unreachable (); }
+ void visit (TyTy::BoolType &) override { rust_unreachable (); }
+ void visit (TyTy::IntType &) override { rust_unreachable (); }
+ void visit (TyTy::UintType &) override { rust_unreachable (); }
+ void visit (TyTy::FloatType &) override { rust_unreachable (); }
+ void visit (TyTy::USizeType &) override { rust_unreachable (); }
+ void visit (TyTy::ISizeType &) override { rust_unreachable (); }
+ void visit (TyTy::ErrorType &) override { rust_unreachable (); }
+ void visit (TyTy::CharType &) override { rust_unreachable (); }
+ void visit (TyTy::ReferenceType &) override { rust_unreachable (); }
+ void visit (TyTy::PointerType &) override { rust_unreachable (); }
+ void visit (TyTy::ParamType &) override { rust_unreachable (); }
+ void visit (TyTy::StrType &) override { rust_unreachable (); }
+ void visit (TyTy::NeverType &) override { rust_unreachable (); }
+ void visit (TyTy::DynamicObjectType &) override { rust_unreachable (); }
+ void visit (TyTy::ClosureType &) override { rust_unreachable (); }
private:
SubstMapper (HirId ref, HIR::GenericArgs *generics, Location locus);
void visit (TyTy::ADTType &type) override;
void visit (TyTy::ClosureType &type) override;
- void visit (TyTy::InferType &) override { gcc_unreachable (); }
- void visit (TyTy::TupleType &) override { gcc_unreachable (); }
- void visit (TyTy::FnPtr &) override { gcc_unreachable (); }
- void visit (TyTy::ArrayType &) override { gcc_unreachable (); }
- void visit (TyTy::SliceType &) override { gcc_unreachable (); }
- void visit (TyTy::BoolType &) override { gcc_unreachable (); }
- void visit (TyTy::IntType &) override { gcc_unreachable (); }
- void visit (TyTy::UintType &) override { gcc_unreachable (); }
- void visit (TyTy::FloatType &) override { gcc_unreachable (); }
- void visit (TyTy::USizeType &) override { gcc_unreachable (); }
- void visit (TyTy::ISizeType &) override { gcc_unreachable (); }
- void visit (TyTy::ErrorType &) override { gcc_unreachable (); }
- void visit (TyTy::CharType &) override { gcc_unreachable (); }
- void visit (TyTy::ReferenceType &) override { gcc_unreachable (); }
- void visit (TyTy::PointerType &) override { gcc_unreachable (); }
- void visit (TyTy::ParamType &) override { gcc_unreachable (); }
- void visit (TyTy::StrType &) override { gcc_unreachable (); }
- void visit (TyTy::NeverType &) override { gcc_unreachable (); }
- void visit (TyTy::PlaceholderType &) override { gcc_unreachable (); }
- void visit (TyTy::ProjectionType &) override { gcc_unreachable (); }
- void visit (TyTy::DynamicObjectType &) override { gcc_unreachable (); }
+ void visit (TyTy::InferType &) override { rust_unreachable (); }
+ void visit (TyTy::TupleType &) override { rust_unreachable (); }
+ void visit (TyTy::FnPtr &) override { rust_unreachable (); }
+ void visit (TyTy::ArrayType &) override { rust_unreachable (); }
+ void visit (TyTy::SliceType &) override { rust_unreachable (); }
+ void visit (TyTy::BoolType &) override { rust_unreachable (); }
+ void visit (TyTy::IntType &) override { rust_unreachable (); }
+ void visit (TyTy::UintType &) override { rust_unreachable (); }
+ void visit (TyTy::FloatType &) override { rust_unreachable (); }
+ void visit (TyTy::USizeType &) override { rust_unreachable (); }
+ void visit (TyTy::ISizeType &) override { rust_unreachable (); }
+ void visit (TyTy::ErrorType &) override { rust_unreachable (); }
+ void visit (TyTy::CharType &) override { rust_unreachable (); }
+ void visit (TyTy::ReferenceType &) override { rust_unreachable (); }
+ void visit (TyTy::PointerType &) override { rust_unreachable (); }
+ void visit (TyTy::ParamType &) override { rust_unreachable (); }
+ void visit (TyTy::StrType &) override { rust_unreachable (); }
+ void visit (TyTy::NeverType &) override { rust_unreachable (); }
+ void visit (TyTy::PlaceholderType &) override { rust_unreachable (); }
+ void visit (TyTy::ProjectionType &) override { rust_unreachable (); }
+ void visit (TyTy::DynamicObjectType &) override { rust_unreachable (); }
private:
SubstMapperFromExisting (TyTy::BaseType *concrete, TyTy::BaseType *receiver);
break;
case ERROR:
- gcc_unreachable ();
+ rust_unreachable ();
return nullptr;
}
return checker.resolved;
}
- void visit (InferType &) override { gcc_unreachable (); }
- void visit (TupleType &) override { gcc_unreachable (); }
- void visit (ArrayType &) override { gcc_unreachable (); }
- void visit (SliceType &) override { gcc_unreachable (); }
- void visit (BoolType &) override { gcc_unreachable (); }
- void visit (IntType &) override { gcc_unreachable (); }
- void visit (UintType &) override { gcc_unreachable (); }
- void visit (FloatType &) override { gcc_unreachable (); }
- void visit (USizeType &) override { gcc_unreachable (); }
- void visit (ISizeType &) override { gcc_unreachable (); }
- void visit (ErrorType &) override { gcc_unreachable (); }
- void visit (CharType &) override { gcc_unreachable (); }
- void visit (ReferenceType &) override { gcc_unreachable (); }
- void visit (PointerType &) override { gcc_unreachable (); }
- void visit (ParamType &) override { gcc_unreachable (); }
- void visit (StrType &) override { gcc_unreachable (); }
- void visit (NeverType &) override { gcc_unreachable (); }
- void visit (PlaceholderType &) override { gcc_unreachable (); }
- void visit (ProjectionType &) override { gcc_unreachable (); }
- void visit (DynamicObjectType &) override { gcc_unreachable (); }
- void visit (ClosureType &type) override { gcc_unreachable (); }
+ void visit (InferType &) override { rust_unreachable (); }
+ void visit (TupleType &) override { rust_unreachable (); }
+ void visit (ArrayType &) override { rust_unreachable (); }
+ void visit (SliceType &) override { rust_unreachable (); }
+ void visit (BoolType &) override { rust_unreachable (); }
+ void visit (IntType &) override { rust_unreachable (); }
+ void visit (UintType &) override { rust_unreachable (); }
+ void visit (FloatType &) override { rust_unreachable (); }
+ void visit (USizeType &) override { rust_unreachable (); }
+ void visit (ISizeType &) override { rust_unreachable (); }
+ void visit (ErrorType &) override { rust_unreachable (); }
+ void visit (CharType &) override { rust_unreachable (); }
+ void visit (ReferenceType &) override { rust_unreachable (); }
+ void visit (PointerType &) override { rust_unreachable (); }
+ void visit (ParamType &) override { rust_unreachable (); }
+ void visit (StrType &) override { rust_unreachable (); }
+ void visit (NeverType &) override { rust_unreachable (); }
+ void visit (PlaceholderType &) override { rust_unreachable (); }
+ void visit (ProjectionType &) override { rust_unreachable (); }
+ void visit (DynamicObjectType &) override { rust_unreachable (); }
+ void visit (ClosureType &type) override { rust_unreachable (); }
// tuple-structs
void visit (ADTType &type) override;
case TypeKind::ERROR:
return "ERROR";
}
- gcc_unreachable ();
+ rust_unreachable ();
}
bool
break;
}
- gcc_unreachable ();
+ rust_unreachable ();
return nullptr;
}
case STRUCT:
return "struct";
}
- gcc_unreachable ();
+ rust_unreachable ();
return "";
}
ClosureType *
ClosureType::handle_substitions (SubstitutionArgumentMappings &mappings)
{
- gcc_unreachable ();
+ rust_unreachable ();
return nullptr;
}
case I128:
return "i128";
}
- gcc_unreachable ();
+ rust_unreachable ();
return "__unknown_int_type";
}
case U128:
return "u128";
}
- gcc_unreachable ();
+ rust_unreachable ();
return "__unknown_uint_type";
}
case F64:
return "f64";
}
- gcc_unreachable ();
+ rust_unreachable ();
return "__unknown_float_type";
}
// FIXME
case TyTy::PROJECTION:
- gcc_unreachable ();
+ rust_unreachable ();
break;
case TyTy::DYNAMIC:
trees.push_back (ProcMacro::TokenStream::make_tokenstream ());
break;
default:
- gcc_unreachable ();
+ rust_unreachable ();
}
}
return trees.back ();
case ProcMacro::STR_RAW:
case ProcMacro::BYTE_STR_RAW:
default:
- gcc_unreachable ();
+ rust_unreachable ();
}
}
from_tokenstream (g.stream, result);
break;
default:
- gcc_unreachable ();
+ rust_unreachable ();
}
}
from_literal (tt.payload.literal, result);
break;
default:
- gcc_unreachable ();
+ rust_unreachable ();
}
}
projects / thirdparty / gcc.git / commitdiff
