diff options
25 files changed, 1305 insertions, 564 deletions
diff --git a/gcc/rust/Make-lang.in b/gcc/rust/Make-lang.in index f59deb8..ae385e0 100644 --- a/gcc/rust/Make-lang.in +++ b/gcc/rust/Make-lang.in @@ -87,6 +87,7 @@ GRS_OBJS = \ rust/rust-ast-lower-pattern.o \ rust/rust-name-resolver.o \ rust/rust-ast-resolve.o \ + rust/rust-ast-resolve-base.o \ rust/rust-ast-resolve-item.o \ rust/rust-ast-resolve-pattern.o \ rust/rust-ast-resolve-expr.o \ diff --git a/gcc/rust/ast/rust-ast.h b/gcc/rust/ast/rust-ast.h index f2b14ab..fb8982a 100644 --- a/gcc/rust/ast/rust-ast.h +++ b/gcc/rust/ast/rust-ast.h @@ -349,6 +349,7 @@ public: Location get_locus () const { return locus; } NodeId get_node_id () const { return node_id; } + const std::string &get_segment_name () const { return segment_name; } // TODO: visitor pattern? }; @@ -404,6 +405,11 @@ public: = {AST::SimplePathSegment (std::move (str), locus)}; return SimplePath (std::move (single_segments)); } + + const std::vector<SimplePathSegment> &get_segments () const + { + return segments; + } }; // path-to-string inverse comparison operator diff --git a/gcc/rust/ast/rust-item.h b/gcc/rust/ast/rust-item.h index 5d1e0d6..9dc61a8 100644 --- a/gcc/rust/ast/rust-item.h +++ b/gcc/rust/ast/rust-item.h @@ -701,6 +701,7 @@ public: std::string as_string () const; const SimplePath &get_path () const { return in_path; } + SimplePath &get_path () { return in_path; } protected: // Clone function implementation - not currently virtual but may be if diff --git a/gcc/rust/backend/rust-compile-expr.cc b/gcc/rust/backend/rust-compile-expr.cc index 2128f25..edeea8d 100644 --- a/gcc/rust/backend/rust-compile-expr.cc +++ b/gcc/rust/backend/rust-compile-expr.cc @@ -497,10 +497,8 @@ CompileExpr::visit (HIR::CallExpr &expr) // must be a call to a function auto fn_address = CompileExpr::Compile (expr.get_fnexpr (), ctx); - auto fncontext = ctx->peek_fn (); - translated - = ctx->get_backend ()->call_expression (fncontext.fndecl, fn_address, args, - nullptr, expr.get_locus ()); + translated = ctx->get_backend ()->call_expression (fn_address, args, nullptr, + expr.get_locus ()); } void @@ -610,10 +608,8 @@ CompileExpr::visit (HIR::MethodCallExpr &expr) args.push_back (rvalue); } - auto fncontext = ctx->peek_fn (); - translated - = ctx->get_backend ()->call_expression (fncontext.fndecl, fn_expr, args, - nullptr, expr.get_locus ()); + translated = ctx->get_backend ()->call_expression (fn_expr, args, nullptr, + expr.get_locus ()); } tree @@ -696,8 +692,8 @@ CompileExpr::compile_dyn_dispatch_call (const TyTy::DynamicObjectType *dyn, tree fn_expr = ctx->get_backend ()->var_expression (fn_convert_expr_tmp, expr_locus); - return ctx->get_backend ()->call_expression (fnctx.fndecl, fn_expr, args, - nullptr, expr_locus); + return ctx->get_backend ()->call_expression (fn_expr, args, nullptr, + expr_locus); } tree @@ -866,9 +862,8 @@ CompileExpr::resolve_operator_overload ( if (rhs != nullptr) // can be null for negation_expr (unary ones) args.push_back (rhs); - auto fncontext = ctx->peek_fn (); - return ctx->get_backend ()->call_expression (fncontext.fndecl, fn_expr, args, - nullptr, expr.get_locus ()); + return ctx->get_backend ()->call_expression (fn_expr, args, nullptr, + expr.get_locus ()); } tree @@ -1289,10 +1284,8 @@ HIRCompileBase::resolve_deref_adjustment (Resolver::Adjustment &adjustment, } // make the call - auto fncontext = ctx->peek_fn (); - return ctx->get_backend ()->call_expression (fncontext.fndecl, fn_address, - {adjusted_argument}, nullptr, - locus); + return ctx->get_backend ()->call_expression (fn_address, {adjusted_argument}, + nullptr, locus); } tree diff --git a/gcc/rust/backend/rust-compile-implitem.cc b/gcc/rust/backend/rust-compile-implitem.cc index 7cc214c..9dc6d14 100644 --- a/gcc/rust/backend/rust-compile-implitem.cc +++ b/gcc/rust/backend/rust-compile-implitem.cc @@ -52,6 +52,7 @@ CompileTraitItem::visit (HIR::TraitItemFunc &func) rust_assert (concrete->get_kind () == TyTy::TypeKind::FNDEF); TyTy::FnType *fntype = static_cast<TyTy::FnType *> (concrete); + fntype->monomorphize (); // items can be forward compiled which means we may not need to invoke this // code. We might also have already compiled this generic function as well. diff --git a/gcc/rust/backend/rust-compile-item.cc b/gcc/rust/backend/rust-compile-item.cc index 80b7ceb..969c852 100644 --- a/gcc/rust/backend/rust-compile-item.cc +++ b/gcc/rust/backend/rust-compile-item.cc @@ -127,6 +127,7 @@ CompileItem::visit (HIR::Function &function) { rust_assert (concrete->get_kind () == TyTy::TypeKind::FNDEF); fntype = static_cast<TyTy::FnType *> (concrete); + fntype->monomorphize (); } } diff --git a/gcc/rust/backend/rust-compile-resolve-path.cc b/gcc/rust/backend/rust-compile-resolve-path.cc index 2ad672d..55a2fff 100644 --- a/gcc/rust/backend/rust-compile-resolve-path.cc +++ b/gcc/rust/backend/rust-compile-resolve-path.cc @@ -251,21 +251,6 @@ HIRCompileBase::query_compile (HirId ref, TyTy::BaseType *lookup, rust_assert (ok); // found rust_assert (trait_item_ref->is_optional ()); // has definition - Analysis::NodeMapping trait_mappings - = trait_item_ref->get_parent_trait_mappings (); - - HirId associated_impl_id; - ok = ctx->get_tyctx ()->lookup_associated_impl_mapping_for_self ( - trait_mappings.get_hirid (), receiver, &associated_impl_id); - rust_assert (ok); - - Resolver::AssociatedImplTrait *associated = nullptr; - bool found_associated_trait_impl - = ctx->get_tyctx ()->lookup_associated_trait_impl ( - associated_impl_id, &associated); - rust_assert (found_associated_trait_impl); - associated->setup_associated_types (); - return CompileTraitItem::Compile ( trait_item_ref->get_hir_trait_item (), ctx, lookup, true, expr_locus); diff --git a/gcc/rust/privacy/rust-visibility-resolver.cc b/gcc/rust/privacy/rust-visibility-resolver.cc index 8f5aeba..3ab6085 100644 --- a/gcc/rust/privacy/rust-visibility-resolver.cc +++ b/gcc/rust/privacy/rust-visibility-resolver.cc @@ -45,6 +45,17 @@ VisibilityResolver::go (HIR::Crate &crate) } } +// FIXME: At this point in the pipeline, we should not be dealing with +// `AST::SimplePath`s anymore! We need to be dealing with their "resolved +// counterpart", so probably a NodeId/HirId/DefId. + +// static bool +// resolve_module_path (std::vector<HIR::Module> &module_stack, +// const AST::SimplePath &restriction, DefId &id) +// { +// return false; +// } + bool VisibilityResolver::resolve_visibility (const HIR::Visibility &visibility, ModuleVisibility &to_resolve) diff --git a/gcc/rust/resolve/rust-ast-resolve-base.cc b/gcc/rust/resolve/rust-ast-resolve-base.cc new file mode 100644 index 0000000..2a86618 --- /dev/null +++ b/gcc/rust/resolve/rust-ast-resolve-base.cc @@ -0,0 +1,654 @@ +// Copyright (C) 2020-2022 Free Software Foundation, Inc. + +// This file is part of GCC. + +// GCC is free software; you can redistribute it and/or modify it under +// the terms of the GNU General Public License as published by the Free +// Software Foundation; either version 3, or (at your option) any later +// version. + +// GCC is distributed in the hope that it will be useful, but WITHOUT ANY +// WARRANTY; without even the implied warranty of MERCHANTABILITY or +// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +// for more details. + +// You should have received a copy of the GNU General Public License +// along with GCC; see the file COPYING3. If not see +// <http://www.gnu.org/licenses/>. + +#include "rust-ast-resolve-base.h" +#include "rust-ast-resolve-expr.h" +#include "rust-ast-resolve-path.h" +#include "rust-item.h" + +namespace Rust { +namespace Resolver { + +bool +ResolverBase::resolve_visibility (const AST::Visibility &vis) +{ + if (vis.has_path ()) + { + auto path = vis.get_path (); + ResolvePath::go (&path, parent); + + // Do we need to lookup something here? + // Is it just about resolving the names correctly so we can look them up + // later? + } + + return true; +} + +// Default visitors implementations + +void +ResolverBase::visit (AST::Token &) +{} + +void +ResolverBase::visit (AST::DelimTokenTree &) +{} + +void +ResolverBase::visit (AST::AttrInputMetaItemContainer &) +{} + +void +ResolverBase::visit (AST::IdentifierExpr &) +{} + +void +ResolverBase::visit (AST::Lifetime &) +{} + +void +ResolverBase::visit (AST::LifetimeParam &) +{} + +void +ResolverBase::visit (AST::PathInExpression &) +{} + +void +ResolverBase::visit (AST::TypePathSegment &) +{} + +void +ResolverBase::visit (AST::TypePathSegmentGeneric &) +{} + +void +ResolverBase::visit (AST::TypePathSegmentFunction &) +{} + +void +ResolverBase::visit (AST::TypePath &) +{} + +void +ResolverBase::visit (AST::QualifiedPathInExpression &) +{} + +void +ResolverBase::visit (AST::QualifiedPathInType &) +{} + +void +ResolverBase::visit (AST::LiteralExpr &) +{} + +void +ResolverBase::visit (AST::AttrInputLiteral &) +{} + +void +ResolverBase::visit (AST::MetaItemLitExpr &) +{} + +void +ResolverBase::visit (AST::MetaItemPathLit &) +{} + +void +ResolverBase::visit (AST::BorrowExpr &) +{} + +void +ResolverBase::visit (AST::DereferenceExpr &) +{} + +void +ResolverBase::visit (AST::ErrorPropagationExpr &) +{} + +void +ResolverBase::visit (AST::NegationExpr &) +{} + +void +ResolverBase::visit (AST::ArithmeticOrLogicalExpr &) +{} + +void +ResolverBase::visit (AST::ComparisonExpr &) +{} + +void +ResolverBase::visit (AST::LazyBooleanExpr &) +{} + +void +ResolverBase::visit (AST::TypeCastExpr &) +{} + +void +ResolverBase::visit (AST::AssignmentExpr &) +{} + +void +ResolverBase::visit (AST::CompoundAssignmentExpr &) +{} + +void +ResolverBase::visit (AST::GroupedExpr &) +{} + +void +ResolverBase::visit (AST::ArrayElemsValues &) +{} + +void +ResolverBase::visit (AST::ArrayElemsCopied &) +{} + +void +ResolverBase::visit (AST::ArrayExpr &) +{} + +void +ResolverBase::visit (AST::ArrayIndexExpr &) +{} + +void +ResolverBase::visit (AST::TupleExpr &) +{} + +void +ResolverBase::visit (AST::TupleIndexExpr &) +{} + +void +ResolverBase::visit (AST::StructExprStruct &) +{} + +void +ResolverBase::visit (AST::StructExprFieldIdentifier &) +{} + +void +ResolverBase::visit (AST::StructExprFieldIdentifierValue &) +{} + +void +ResolverBase::visit (AST::StructExprFieldIndexValue &) +{} + +void +ResolverBase::visit (AST::StructExprStructFields &) +{} + +void +ResolverBase::visit (AST::StructExprStructBase &) +{} + +void +ResolverBase::visit (AST::CallExpr &) +{} + +void +ResolverBase::visit (AST::MethodCallExpr &) +{} + +void +ResolverBase::visit (AST::FieldAccessExpr &) +{} + +void +ResolverBase::visit (AST::ClosureExprInner &) +{} + +void +ResolverBase::visit (AST::BlockExpr &) +{} + +void +ResolverBase::visit (AST::ClosureExprInnerTyped &) +{} + +void +ResolverBase::visit (AST::ContinueExpr &) +{} + +void +ResolverBase::visit (AST::BreakExpr &) +{} + +void +ResolverBase::visit (AST::RangeFromToExpr &) +{} + +void +ResolverBase::visit (AST::RangeFromExpr &) +{} + +void +ResolverBase::visit (AST::RangeToExpr &) +{} + +void +ResolverBase::visit (AST::RangeFullExpr &) +{} + +void +ResolverBase::visit (AST::RangeFromToInclExpr &) +{} + +void +ResolverBase::visit (AST::RangeToInclExpr &) +{} + +void +ResolverBase::visit (AST::ReturnExpr &) +{} + +void +ResolverBase::visit (AST::UnsafeBlockExpr &) +{} + +void +ResolverBase::visit (AST::LoopExpr &) +{} + +void +ResolverBase::visit (AST::WhileLoopExpr &) +{} + +void +ResolverBase::visit (AST::WhileLetLoopExpr &) +{} + +void +ResolverBase::visit (AST::ForLoopExpr &) +{} + +void +ResolverBase::visit (AST::IfExpr &) +{} + +void +ResolverBase::visit (AST::IfExprConseqElse &) +{} + +void +ResolverBase::visit (AST::IfExprConseqIf &) +{} + +void +ResolverBase::visit (AST::IfExprConseqIfLet &) +{} + +void +ResolverBase::visit (AST::IfLetExpr &) +{} + +void +ResolverBase::visit (AST::IfLetExprConseqElse &) +{} + +void +ResolverBase::visit (AST::IfLetExprConseqIf &) +{} + +void +ResolverBase::visit (AST::IfLetExprConseqIfLet &) +{} + +void +ResolverBase::visit (AST::MatchExpr &) +{} + +void +ResolverBase::visit (AST::AwaitExpr &) +{} + +void +ResolverBase::visit (AST::AsyncBlockExpr &) +{} + +void +ResolverBase::visit (AST::TypeParam &) +{} + +void +ResolverBase::visit (AST::LifetimeWhereClauseItem &) +{} + +void +ResolverBase::visit (AST::TypeBoundWhereClauseItem &) +{} + +void +ResolverBase::visit (AST::Method &) +{} + +void +ResolverBase::visit (AST::Module &) +{} + +void +ResolverBase::visit (AST::ExternCrate &) +{} + +void +ResolverBase::visit (AST::UseTreeGlob &) +{} + +void +ResolverBase::visit (AST::UseTreeList &) +{} + +void +ResolverBase::visit (AST::UseTreeRebind &) +{} + +void +ResolverBase::visit (AST::UseDeclaration &) +{} + +void +ResolverBase::visit (AST::Function &) +{} + +void +ResolverBase::visit (AST::TypeAlias &) +{} + +void +ResolverBase::visit (AST::StructStruct &) +{} + +void +ResolverBase::visit (AST::TupleStruct &) +{} + +void +ResolverBase::visit (AST::EnumItem &) +{} + +void +ResolverBase::visit (AST::EnumItemTuple &) +{} + +void +ResolverBase::visit (AST::EnumItemStruct &) +{} + +void +ResolverBase::visit (AST::EnumItemDiscriminant &) +{} + +void +ResolverBase::visit (AST::Enum &) +{} + +void +ResolverBase::visit (AST::Union &) +{} + +void +ResolverBase::visit (AST::ConstantItem &) +{} + +void +ResolverBase::visit (AST::StaticItem &) +{} + +void +ResolverBase::visit (AST::TraitItemFunc &) +{} + +void +ResolverBase::visit (AST::TraitItemMethod &) +{} + +void +ResolverBase::visit (AST::TraitItemConst &) +{} + +void +ResolverBase::visit (AST::TraitItemType &) +{} + +void +ResolverBase::visit (AST::Trait &) +{} + +void +ResolverBase::visit (AST::InherentImpl &) +{} + +void +ResolverBase::visit (AST::TraitImpl &) +{} + +void +ResolverBase::visit (AST::ExternalStaticItem &) +{} + +void +ResolverBase::visit (AST::ExternalFunctionItem &) +{} + +void +ResolverBase::visit (AST::ExternBlock &) +{} + +void +ResolverBase::visit (AST::MacroMatchFragment &) +{} + +void +ResolverBase::visit (AST::MacroMatchRepetition &) +{} + +void +ResolverBase::visit (AST::MacroMatcher &) +{} + +void +ResolverBase::visit (AST::MacroRulesDefinition &) +{} + +void +ResolverBase::visit (AST::MacroInvocation &) +{} + +void +ResolverBase::visit (AST::MetaItemPath &) +{} + +void +ResolverBase::visit (AST::MetaItemSeq &) +{} + +void +ResolverBase::visit (AST::MetaWord &) +{} + +void +ResolverBase::visit (AST::MetaNameValueStr &) +{} + +void +ResolverBase::visit (AST::MetaListPaths &) +{} + +void +ResolverBase::visit (AST::MetaListNameValueStr &) +{} + +void +ResolverBase::visit (AST::LiteralPattern &) +{} + +void +ResolverBase::visit (AST::IdentifierPattern &) +{} + +void +ResolverBase::visit (AST::WildcardPattern &) +{} + +void +ResolverBase::visit (AST::RangePatternBoundLiteral &) +{} + +void +ResolverBase::visit (AST::RangePatternBoundPath &) +{} + +void +ResolverBase::visit (AST::RangePatternBoundQualPath &) +{} + +void +ResolverBase::visit (AST::RangePattern &) +{} + +void +ResolverBase::visit (AST::ReferencePattern &) +{} + +void +ResolverBase::visit (AST::StructPatternFieldTuplePat &) +{} + +void +ResolverBase::visit (AST::StructPatternFieldIdentPat &) +{} + +void +ResolverBase::visit (AST::StructPatternFieldIdent &) +{} + +void +ResolverBase::visit (AST::StructPattern &) +{} + +void +ResolverBase::visit (AST::TupleStructItemsNoRange &) +{} + +void +ResolverBase::visit (AST::TupleStructItemsRange &) +{} + +void +ResolverBase::visit (AST::TupleStructPattern &) +{} + +void +ResolverBase::visit (AST::TuplePatternItemsMultiple &) +{} + +void +ResolverBase::visit (AST::TuplePatternItemsRanged &) +{} + +void +ResolverBase::visit (AST::TuplePattern &) +{} + +void +ResolverBase::visit (AST::GroupedPattern &) +{} + +void +ResolverBase::visit (AST::SlicePattern &) +{} + +void +ResolverBase::visit (AST::EmptyStmt &) +{} + +void +ResolverBase::visit (AST::LetStmt &) +{} + +void +ResolverBase::visit (AST::ExprStmtWithoutBlock &) +{} + +void +ResolverBase::visit (AST::ExprStmtWithBlock &) +{} + +void +ResolverBase::visit (AST::TraitBound &) +{} + +void +ResolverBase::visit (AST::ImplTraitType &) +{} + +void +ResolverBase::visit (AST::TraitObjectType &) +{} + +void +ResolverBase::visit (AST::ParenthesisedType &) +{} + +void +ResolverBase::visit (AST::ImplTraitTypeOneBound &) +{} + +void +ResolverBase::visit (AST::TraitObjectTypeOneBound &) +{} + +void +ResolverBase::visit (AST::TupleType &) +{} + +void +ResolverBase::visit (AST::NeverType &) +{} + +void +ResolverBase::visit (AST::RawPointerType &) +{} + +void +ResolverBase::visit (AST::ReferenceType &) +{} + +void +ResolverBase::visit (AST::ArrayType &) +{} + +void +ResolverBase::visit (AST::SliceType &) +{} + +void +ResolverBase::visit (AST::InferredType &) +{} + +void +ResolverBase::visit (AST::BareFunctionType &) +{} + +} // namespace Resolver +} // namespace Rust diff --git a/gcc/rust/resolve/rust-ast-resolve-base.h b/gcc/rust/resolve/rust-ast-resolve-base.h index eca9694..17d05c3 100644 --- a/gcc/rust/resolve/rust-ast-resolve-base.h +++ b/gcc/rust/resolve/rust-ast-resolve-base.h @@ -32,171 +32,171 @@ class ResolverBase : public AST::ASTVisitor public: virtual ~ResolverBase () {} - void visit (AST::Token &) {} - void visit (AST::DelimTokenTree &) {} - void visit (AST::AttrInputMetaItemContainer &) {} - void visit (AST::IdentifierExpr &) {} - void visit (AST::Lifetime &) {} - void visit (AST::LifetimeParam &) {} - void visit (AST::PathInExpression &) {} - void visit (AST::TypePathSegment &) {} - void visit (AST::TypePathSegmentGeneric &) {} - void visit (AST::TypePathSegmentFunction &) {} - void visit (AST::TypePath &) {} - void visit (AST::QualifiedPathInExpression &) {} - void visit (AST::QualifiedPathInType &) {} - void visit (AST::LiteralExpr &) {} - void visit (AST::AttrInputLiteral &) {} - void visit (AST::MetaItemLitExpr &) {} - void visit (AST::MetaItemPathLit &) {} - void visit (AST::BorrowExpr &) {} - void visit (AST::DereferenceExpr &) {} - void visit (AST::ErrorPropagationExpr &) {} - void visit (AST::NegationExpr &) {} - void visit (AST::ArithmeticOrLogicalExpr &) {} - void visit (AST::ComparisonExpr &) {} - void visit (AST::LazyBooleanExpr &) {} - void visit (AST::TypeCastExpr &) {} - void visit (AST::AssignmentExpr &) {} - void visit (AST::CompoundAssignmentExpr &) {} - void visit (AST::GroupedExpr &) {} - void visit (AST::ArrayElemsValues &) {} - void visit (AST::ArrayElemsCopied &) {} - void visit (AST::ArrayExpr &) {} - void visit (AST::ArrayIndexExpr &) {} - void visit (AST::TupleExpr &) {} - void visit (AST::TupleIndexExpr &) {} - void visit (AST::StructExprStruct &) {} - void visit (AST::StructExprFieldIdentifier &) {} - void visit (AST::StructExprFieldIdentifierValue &) {} - void visit (AST::StructExprFieldIndexValue &) {} - void visit (AST::StructExprStructFields &) {} - void visit (AST::StructExprStructBase &) {} - void visit (AST::CallExpr &) {} - void visit (AST::MethodCallExpr &) {} - void visit (AST::FieldAccessExpr &) {} - void visit (AST::ClosureExprInner &) {} - void visit (AST::BlockExpr &) {} - void visit (AST::ClosureExprInnerTyped &) {} - void visit (AST::ContinueExpr &) {} - void visit (AST::BreakExpr &) {} - void visit (AST::RangeFromToExpr &) {} - void visit (AST::RangeFromExpr &) {} - void visit (AST::RangeToExpr &) {} - void visit (AST::RangeFullExpr &) {} - void visit (AST::RangeFromToInclExpr &) {} - void visit (AST::RangeToInclExpr &) {} - void visit (AST::ReturnExpr &) {} - void visit (AST::UnsafeBlockExpr &) {} - void visit (AST::LoopExpr &) {} - void visit (AST::WhileLoopExpr &) {} - void visit (AST::WhileLetLoopExpr &) {} - void visit (AST::ForLoopExpr &) {} - void visit (AST::IfExpr &) {} - void visit (AST::IfExprConseqElse &) {} - void visit (AST::IfExprConseqIf &) {} - void visit (AST::IfExprConseqIfLet &) {} - void visit (AST::IfLetExpr &) {} - void visit (AST::IfLetExprConseqElse &) {} - void visit (AST::IfLetExprConseqIf &) {} - void visit (AST::IfLetExprConseqIfLet &) {} - - void visit (AST::MatchExpr &) {} - void visit (AST::AwaitExpr &) {} - void visit (AST::AsyncBlockExpr &) {} - - void visit (AST::TypeParam &) {} - - void visit (AST::LifetimeWhereClauseItem &) {} - void visit (AST::TypeBoundWhereClauseItem &) {} - void visit (AST::Method &) {} - void visit (AST::Module &) {} - void visit (AST::ExternCrate &) {} - - void visit (AST::UseTreeGlob &) {} - void visit (AST::UseTreeList &) {} - void visit (AST::UseTreeRebind &) {} - void visit (AST::UseDeclaration &) {} - void visit (AST::Function &) {} - void visit (AST::TypeAlias &) {} - void visit (AST::StructStruct &) {} - void visit (AST::TupleStruct &) {} - void visit (AST::EnumItem &) {} - void visit (AST::EnumItemTuple &) {} - void visit (AST::EnumItemStruct &) {} - void visit (AST::EnumItemDiscriminant &) {} - void visit (AST::Enum &) {} - void visit (AST::Union &) {} - void visit (AST::ConstantItem &) {} - void visit (AST::StaticItem &) {} - void visit (AST::TraitItemFunc &) {} - void visit (AST::TraitItemMethod &) {} - void visit (AST::TraitItemConst &) {} - void visit (AST::TraitItemType &) {} - void visit (AST::Trait &) {} - void visit (AST::InherentImpl &) {} - void visit (AST::TraitImpl &) {} - - void visit (AST::ExternalStaticItem &) {} - void visit (AST::ExternalFunctionItem &) {} - void visit (AST::ExternBlock &) {} - - void visit (AST::MacroMatchFragment &) {} - void visit (AST::MacroMatchRepetition &) {} - void visit (AST::MacroMatcher &) {} - void visit (AST::MacroRulesDefinition &) {} - void visit (AST::MacroInvocation &) {} - void visit (AST::MetaItemPath &) {} - void visit (AST::MetaItemSeq &) {} - void visit (AST::MetaWord &) {} - void visit (AST::MetaNameValueStr &) {} - void visit (AST::MetaListPaths &) {} - void visit (AST::MetaListNameValueStr &) {} - - void visit (AST::LiteralPattern &) {} - void visit (AST::IdentifierPattern &) {} - void visit (AST::WildcardPattern &) {} - - void visit (AST::RangePatternBoundLiteral &) {} - void visit (AST::RangePatternBoundPath &) {} - void visit (AST::RangePatternBoundQualPath &) {} - void visit (AST::RangePattern &) {} - void visit (AST::ReferencePattern &) {} - - void visit (AST::StructPatternFieldTuplePat &) {} - void visit (AST::StructPatternFieldIdentPat &) {} - void visit (AST::StructPatternFieldIdent &) {} - void visit (AST::StructPattern &) {} - - void visit (AST::TupleStructItemsNoRange &) {} - void visit (AST::TupleStructItemsRange &) {} - void visit (AST::TupleStructPattern &) {} - - void visit (AST::TuplePatternItemsMultiple &) {} - void visit (AST::TuplePatternItemsRanged &) {} - void visit (AST::TuplePattern &) {} - void visit (AST::GroupedPattern &) {} - void visit (AST::SlicePattern &) {} - - void visit (AST::EmptyStmt &) {} - void visit (AST::LetStmt &) {} - void visit (AST::ExprStmtWithoutBlock &) {} - void visit (AST::ExprStmtWithBlock &) {} - - void visit (AST::TraitBound &) {} - void visit (AST::ImplTraitType &) {} - void visit (AST::TraitObjectType &) {} - void visit (AST::ParenthesisedType &) {} - void visit (AST::ImplTraitTypeOneBound &) {} - void visit (AST::TraitObjectTypeOneBound &) {} - void visit (AST::TupleType &) {} - void visit (AST::NeverType &) {} - void visit (AST::RawPointerType &) {} - void visit (AST::ReferenceType &) {} - void visit (AST::ArrayType &) {} - void visit (AST::SliceType &) {} - void visit (AST::InferredType &) {} - void visit (AST::BareFunctionType &) {} + void visit (AST::Token &); + void visit (AST::DelimTokenTree &); + void visit (AST::AttrInputMetaItemContainer &); + void visit (AST::IdentifierExpr &); + void visit (AST::Lifetime &); + void visit (AST::LifetimeParam &); + void visit (AST::PathInExpression &); + void visit (AST::TypePathSegment &); + void visit (AST::TypePathSegmentGeneric &); + void visit (AST::TypePathSegmentFunction &); + void visit (AST::TypePath &); + void visit (AST::QualifiedPathInExpression &); + void visit (AST::QualifiedPathInType &); + void visit (AST::LiteralExpr &); + void visit (AST::AttrInputLiteral &); + void visit (AST::MetaItemLitExpr &); + void visit (AST::MetaItemPathLit &); + void visit (AST::BorrowExpr &); + void visit (AST::DereferenceExpr &); + void visit (AST::ErrorPropagationExpr &); + void visit (AST::NegationExpr &); + void visit (AST::ArithmeticOrLogicalExpr &); + void visit (AST::ComparisonExpr &); + void visit (AST::LazyBooleanExpr &); + void visit (AST::TypeCastExpr &); + void visit (AST::AssignmentExpr &); + void visit (AST::CompoundAssignmentExpr &); + void visit (AST::GroupedExpr &); + void visit (AST::ArrayElemsValues &); + void visit (AST::ArrayElemsCopied &); + void visit (AST::ArrayExpr &); + void visit (AST::ArrayIndexExpr &); + void visit (AST::TupleExpr &); + void visit (AST::TupleIndexExpr &); + void visit (AST::StructExprStruct &); + void visit (AST::StructExprFieldIdentifier &); + void visit (AST::StructExprFieldIdentifierValue &); + void visit (AST::StructExprFieldIndexValue &); + void visit (AST::StructExprStructFields &); + void visit (AST::StructExprStructBase &); + void visit (AST::CallExpr &); + void visit (AST::MethodCallExpr &); + void visit (AST::FieldAccessExpr &); + void visit (AST::ClosureExprInner &); + void visit (AST::BlockExpr &); + void visit (AST::ClosureExprInnerTyped &); + void visit (AST::ContinueExpr &); + void visit (AST::BreakExpr &); + void visit (AST::RangeFromToExpr &); + void visit (AST::RangeFromExpr &); + void visit (AST::RangeToExpr &); + void visit (AST::RangeFullExpr &); + void visit (AST::RangeFromToInclExpr &); + void visit (AST::RangeToInclExpr &); + void visit (AST::ReturnExpr &); + void visit (AST::UnsafeBlockExpr &); + void visit (AST::LoopExpr &); + void visit (AST::WhileLoopExpr &); + void visit (AST::WhileLetLoopExpr &); + void visit (AST::ForLoopExpr &); + void visit (AST::IfExpr &); + void visit (AST::IfExprConseqElse &); + void visit (AST::IfExprConseqIf &); + void visit (AST::IfExprConseqIfLet &); + void visit (AST::IfLetExpr &); + void visit (AST::IfLetExprConseqElse &); + void visit (AST::IfLetExprConseqIf &); + void visit (AST::IfLetExprConseqIfLet &); + + void visit (AST::MatchExpr &); + void visit (AST::AwaitExpr &); + void visit (AST::AsyncBlockExpr &); + + void visit (AST::TypeParam &); + + void visit (AST::LifetimeWhereClauseItem &); + void visit (AST::TypeBoundWhereClauseItem &); + void visit (AST::Method &); + void visit (AST::Module &); + void visit (AST::ExternCrate &); + + void visit (AST::UseTreeGlob &); + void visit (AST::UseTreeList &); + void visit (AST::UseTreeRebind &); + void visit (AST::UseDeclaration &); + void visit (AST::Function &); + void visit (AST::TypeAlias &); + void visit (AST::StructStruct &); + void visit (AST::TupleStruct &); + void visit (AST::EnumItem &); + void visit (AST::EnumItemTuple &); + void visit (AST::EnumItemStruct &); + void visit (AST::EnumItemDiscriminant &); + void visit (AST::Enum &); + void visit (AST::Union &); + void visit (AST::ConstantItem &); + void visit (AST::StaticItem &); + void visit (AST::TraitItemFunc &); + void visit (AST::TraitItemMethod &); + void visit (AST::TraitItemConst &); + void visit (AST::TraitItemType &); + void visit (AST::Trait &); + void visit (AST::InherentImpl &); + void visit (AST::TraitImpl &); + + void visit (AST::ExternalStaticItem &); + void visit (AST::ExternalFunctionItem &); + void visit (AST::ExternBlock &); + + void visit (AST::MacroMatchFragment &); + void visit (AST::MacroMatchRepetition &); + void visit (AST::MacroMatcher &); + void visit (AST::MacroRulesDefinition &); + void visit (AST::MacroInvocation &); + void visit (AST::MetaItemPath &); + void visit (AST::MetaItemSeq &); + void visit (AST::MetaWord &); + void visit (AST::MetaNameValueStr &); + void visit (AST::MetaListPaths &); + void visit (AST::MetaListNameValueStr &); + + void visit (AST::LiteralPattern &); + void visit (AST::IdentifierPattern &); + void visit (AST::WildcardPattern &); + + void visit (AST::RangePatternBoundLiteral &); + void visit (AST::RangePatternBoundPath &); + void visit (AST::RangePatternBoundQualPath &); + void visit (AST::RangePattern &); + void visit (AST::ReferencePattern &); + + void visit (AST::StructPatternFieldTuplePat &); + void visit (AST::StructPatternFieldIdentPat &); + void visit (AST::StructPatternFieldIdent &); + void visit (AST::StructPattern &); + + void visit (AST::TupleStructItemsNoRange &); + void visit (AST::TupleStructItemsRange &); + void visit (AST::TupleStructPattern &); + + void visit (AST::TuplePatternItemsMultiple &); + void visit (AST::TuplePatternItemsRanged &); + void visit (AST::TuplePattern &); + void visit (AST::GroupedPattern &); + void visit (AST::SlicePattern &); + + void visit (AST::EmptyStmt &); + void visit (AST::LetStmt &); + void visit (AST::ExprStmtWithoutBlock &); + void visit (AST::ExprStmtWithBlock &); + + void visit (AST::TraitBound &); + void visit (AST::ImplTraitType &); + void visit (AST::TraitObjectType &); + void visit (AST::ParenthesisedType &); + void visit (AST::ImplTraitTypeOneBound &); + void visit (AST::TraitObjectTypeOneBound &); + void visit (AST::TupleType &); + void visit (AST::NeverType &); + void visit (AST::RawPointerType &); + void visit (AST::ReferenceType &); + void visit (AST::ArrayType &); + void visit (AST::SliceType &); + void visit (AST::InferredType &); + void visit (AST::BareFunctionType &); protected: ResolverBase (NodeId parent) @@ -206,6 +206,11 @@ protected: bool resolved () const { return resolved_node != UNKNOWN_NODEID; } + /** + * Resolve a visibility's path through the name resolver + */ + bool resolve_visibility (const AST::Visibility &vis); + Resolver *resolver; Analysis::Mappings *mappings; NodeId resolved_node; diff --git a/gcc/rust/resolve/rust-ast-resolve-item.cc b/gcc/rust/resolve/rust-ast-resolve-item.cc index 9546698..2c383c9 100644 --- a/gcc/rust/resolve/rust-ast-resolve-item.cc +++ b/gcc/rust/resolve/rust-ast-resolve-item.cc @@ -238,6 +238,8 @@ ResolveItem::visit (AST::Module &module) mappings->insert_canonical_path (mappings->get_current_crate (), module.get_node_id (), cpath); + resolve_visibility (module.get_visibility ()); + NodeId scope_node_id = module.get_node_id (); resolver->get_name_scope ().push (scope_node_id); resolver->get_type_scope ().push (scope_node_id); @@ -267,6 +269,8 @@ ResolveItem::visit (AST::TupleStruct &struct_decl) mappings->insert_canonical_path (mappings->get_current_crate (), struct_decl.get_node_id (), cpath); + resolve_visibility (struct_decl.get_visibility ()); + NodeId scope_node_id = struct_decl.get_node_id (); resolver->get_type_scope ().push (scope_node_id); @@ -286,6 +290,8 @@ ResolveItem::visit (AST::TupleStruct &struct_decl) if (field.get_field_type ()->is_marked_for_strip ()) continue; + resolve_visibility (field.get_visibility ()); + ResolveType::go (field.get_field_type ().get (), struct_decl.get_node_id ()); } @@ -303,6 +309,8 @@ ResolveItem::visit (AST::Enum &enum_decl) mappings->insert_canonical_path (mappings->get_current_crate (), enum_decl.get_node_id (), cpath); + resolve_visibility (enum_decl.get_visibility ()); + NodeId scope_node_id = enum_decl.get_node_id (); resolver->get_type_scope ().push (scope_node_id); @@ -328,6 +336,9 @@ ResolveItem::visit (AST::Enum &enum_decl) void ResolveItem::visit (AST::EnumItem &item) { + // Since at this point we cannot have visibilities on enum items anymore, we + // can skip handling them + auto decl = CanonicalPath::new_seg (item.get_node_id (), item.get_identifier ()); auto path = prefix.append (decl); @@ -396,6 +407,8 @@ ResolveItem::visit (AST::StructStruct &struct_decl) mappings->insert_canonical_path (mappings->get_current_crate (), struct_decl.get_node_id (), cpath); + resolve_visibility (struct_decl.get_visibility ()); + NodeId scope_node_id = struct_decl.get_node_id (); resolver->get_type_scope ().push (scope_node_id); @@ -415,6 +428,8 @@ ResolveItem::visit (AST::StructStruct &struct_decl) if (field.get_field_type ()->is_marked_for_strip ()) continue; + resolve_visibility (field.get_visibility ()); + ResolveType::go (field.get_field_type ().get (), struct_decl.get_node_id ()); } @@ -432,6 +447,8 @@ ResolveItem::visit (AST::Union &union_decl) mappings->insert_canonical_path (mappings->get_current_crate (), union_decl.get_node_id (), cpath); + resolve_visibility (union_decl.get_visibility ()); + NodeId scope_node_id = union_decl.get_node_id (); resolver->get_type_scope ().push (scope_node_id); @@ -485,6 +502,8 @@ ResolveItem::visit (AST::ConstantItem &constant) mappings->insert_canonical_path (mappings->get_current_crate (), constant.get_node_id (), cpath); + resolve_visibility (constant.get_visibility ()); + ResolveType::go (constant.get_type ().get (), constant.get_node_id ()); ResolveExpr::go (constant.get_expr ().get (), constant.get_node_id (), path, cpath); @@ -505,6 +524,8 @@ ResolveItem::visit (AST::Function &function) mappings->insert_canonical_path (mappings->get_current_crate (), function.get_node_id (), cpath); + resolve_visibility (function.get_visibility ()); + NodeId scope_node_id = function.get_node_id (); resolver->get_name_scope ().push (scope_node_id); resolver->get_type_scope ().push (scope_node_id); @@ -559,6 +580,8 @@ ResolveItem::visit (AST::InherentImpl &impl_block) resolver->push_new_name_rib (resolver->get_name_scope ().peek ()); resolver->push_new_type_rib (resolver->get_type_scope ().peek ()); + resolve_visibility (impl_block.get_visibility ()); + if (impl_block.has_generics ()) { for (auto &generic : impl_block.get_generic_params ()) @@ -640,6 +663,9 @@ ResolveItem::visit (AST::Method &method) method.get_node_id (), cpath); NodeId scope_node_id = method.get_node_id (); + + resolve_visibility (method.get_visibility ()); + resolver->get_name_scope ().push (scope_node_id); resolver->get_type_scope ().push (scope_node_id); resolver->get_label_scope ().push (scope_node_id); @@ -711,6 +737,9 @@ void ResolveItem::visit (AST::TraitImpl &impl_block) { NodeId scope_node_id = impl_block.get_node_id (); + + resolve_visibility (impl_block.get_visibility ()); + resolver->get_name_scope ().push (scope_node_id); resolver->get_type_scope ().push (scope_node_id); resolver->push_new_name_rib (resolver->get_name_scope ().peek ()); @@ -812,6 +841,9 @@ void ResolveItem::visit (AST::Trait &trait) { NodeId scope_node_id = trait.get_node_id (); + + resolve_visibility (trait.get_visibility ()); + resolver->get_name_scope ().push (scope_node_id); resolver->get_type_scope ().push (scope_node_id); resolver->push_new_name_rib (resolver->get_name_scope ().peek ()); @@ -862,6 +894,8 @@ ResolveItem::visit (AST::Trait &trait) void ResolveItem::visit (AST::ExternBlock &extern_block) { + resolve_visibility (extern_block.get_visibility ()); + for (auto &item : extern_block.get_extern_items ()) { resolve_extern_item (item.get ()); @@ -895,6 +929,8 @@ ResolveImplItems::visit (AST::TypeAlias &alias) { ResolveItem::visit (alias); + resolve_visibility (alias.get_visibility ()); + // FIXME this stops the erronious unused decls which will be fixed later on resolver->get_type_scope ().append_reference_for_def (alias.get_node_id (), alias.get_node_id ()); @@ -911,6 +947,9 @@ void ResolveExternItem::visit (AST::ExternalFunctionItem &function) { NodeId scope_node_id = function.get_node_id (); + + resolve_visibility (function.get_visibility ()); + resolver->get_name_scope ().push (scope_node_id); resolver->get_type_scope ().push (scope_node_id); resolver->get_label_scope ().push (scope_node_id); @@ -945,6 +984,8 @@ ResolveExternItem::visit (AST::ExternalFunctionItem &function) void ResolveExternItem::visit (AST::ExternalStaticItem &item) { + resolve_visibility (item.get_visibility ()); + ResolveType::go (item.get_type ().get (), item.get_node_id ()); } diff --git a/gcc/rust/resolve/rust-ast-resolve-path.cc b/gcc/rust/resolve/rust-ast-resolve-path.cc index 7aec4f8..c7597a2 100644 --- a/gcc/rust/resolve/rust-ast-resolve-path.cc +++ b/gcc/rust/resolve/rust-ast-resolve-path.cc @@ -38,6 +38,13 @@ ResolvePath::go (AST::QualifiedPathInExpression *expr, NodeId parent) } void +ResolvePath::go (AST::SimplePath *expr, NodeId parent) +{ + ResolvePath resolver (parent); + resolver.resolve_path (expr); +} + +void ResolvePath::resolve_path (AST::PathInExpression *expr) { // resolve root segment first then apply segments in turn @@ -272,5 +279,70 @@ ResolvePath::resolve_segments (CanonicalPath prefix, size_t offs, } } +static bool +lookup_and_insert_segment (Resolver *resolver, CanonicalPath path, + NodeId segment_id, NodeId *to_resolve, bool &is_type) +{ + if (resolver->get_name_scope ().lookup (path, to_resolve)) + { + resolver->insert_resolved_name (segment_id, *to_resolve); + } + else if (resolver->get_type_scope ().lookup (path, to_resolve)) + { + is_type = true; + resolver->insert_resolved_type (segment_id, *to_resolve); + } + else + { + return false; + } + + return true; +} + +void +ResolvePath::resolve_path (AST::SimplePath *simple_path) +{ + // resolve root segment first then apply segments in turn + auto expr_node_id = simple_path->get_node_id (); + auto is_type = false; + + auto path = CanonicalPath::create_empty (); + for (const auto &seg : simple_path->get_segments ()) + { + auto s = ResolveSimplePathSegmentToCanonicalPath::resolve (seg); + path = path.append (s); + + // Reset state + resolved_node = UNKNOWN_NODEID; + is_type = false; + + if (!lookup_and_insert_segment (resolver, path, seg.get_node_id (), + &resolved_node, is_type)) + { + rust_error_at (seg.get_locus (), + "cannot find simple path segment %qs", + seg.as_string ().c_str ()); + return; + } + } + + if (resolved_node == UNKNOWN_NODEID) + { + rust_error_at (simple_path->get_locus (), + "could not resolve simple path %qs", + simple_path->as_string ().c_str ()); + return; + } + + if (is_type) + resolver->insert_resolved_type (expr_node_id, resolved_node); + else + resolver->insert_resolved_name (expr_node_id, resolved_node); + + resolver->insert_new_definition (expr_node_id, + Definition{expr_node_id, parent}); +} + } // namespace Resolver } // namespace Rust diff --git a/gcc/rust/resolve/rust-ast-resolve-path.h b/gcc/rust/resolve/rust-ast-resolve-path.h index 7a4413b..cbfe967 100644 --- a/gcc/rust/resolve/rust-ast-resolve-path.h +++ b/gcc/rust/resolve/rust-ast-resolve-path.h @@ -31,16 +31,33 @@ class ResolvePath : public ResolverBase public: static void go (AST::PathInExpression *expr, NodeId parent); static void go (AST::QualifiedPathInExpression *expr, NodeId parent); + static void go (AST::SimplePath *expr, NodeId parent); private: ResolvePath (NodeId parent) : ResolverBase (parent) {} void resolve_path (AST::PathInExpression *expr); void resolve_path (AST::QualifiedPathInExpression *expr); + void resolve_path (AST::SimplePath *expr); void resolve_segments (CanonicalPath prefix, size_t offs, std::vector<AST::PathExprSegment> &segs, NodeId expr_node_id, Location expr_locus); + + void + resolve_simple_path_segments (CanonicalPath prefix, size_t offs, + const std::vector<AST::SimplePathSegment> &segs, + NodeId expr_node_id, Location expr_locus); +}; + +class ResolveSimplePathSegmentToCanonicalPath +{ +public: + static CanonicalPath resolve (const AST::SimplePathSegment &seg) + { + // FIXME: Since this is so simple, maybe it can simply be a tiny function? + return CanonicalPath::new_seg (seg.get_node_id (), seg.get_segment_name ()); + } }; } // namespace Resolver diff --git a/gcc/rust/rust-backend.h b/gcc/rust/rust-backend.h index 17b7bae..6d631a0 100644 --- a/gcc/rust/rust-backend.h +++ b/gcc/rust/rust-backend.h @@ -285,8 +285,7 @@ public: // Create an expression for a call to FN with ARGS, taking place within // caller CALLER. - virtual tree call_expression (tree caller, tree fn, - const std::vector<tree> &args, + virtual tree call_expression (tree fn, const std::vector<tree> &args, tree static_chain, Location) = 0; diff --git a/gcc/rust/rust-gcc.cc b/gcc/rust/rust-gcc.cc index 334e9e5..445cb0d 100644 --- a/gcc/rust/rust-gcc.cc +++ b/gcc/rust/rust-gcc.cc @@ -250,7 +250,7 @@ public: tree array_index_expression (tree array, tree index, Location); - tree call_expression (tree caller, tree fn, const std::vector<tree> &args, + tree call_expression (tree fn, const std::vector<tree> &args, tree static_chain, Location); // Statements. @@ -1794,8 +1794,7 @@ Gcc_backend::array_index_expression (tree array_tree, tree index_tree, // Create an expression for a call to FN_EXPR with FN_ARGS. tree -Gcc_backend::call_expression (tree, // containing fcn for call - tree fn, const std::vector<tree> &fn_args, +Gcc_backend::call_expression (tree fn, const std::vector<tree> &fn_args, tree chain_expr, Location location) { if (fn == error_mark_node || TREE_TYPE (fn) == error_mark_node) diff --git a/gcc/rust/typecheck/rust-hir-path-probe.h b/gcc/rust/typecheck/rust-hir-path-probe.h index fda505a..348b9f7 100644 --- a/gcc/rust/typecheck/rust-hir-path-probe.h +++ b/gcc/rust/typecheck/rust-hir-path-probe.h @@ -326,18 +326,6 @@ protected: } TyTy::BaseType *trait_item_tyty = trait_item_ref->get_tyty (); - if (impl != nullptr && !is_reciever_generic ()) - - { - HirId impl_block_id = impl->get_mappings ().get_hirid (); - AssociatedImplTrait *lookup_associated = nullptr; - bool found_impl_trait - = context->lookup_associated_trait_impl (impl_block_id, - &lookup_associated); - // see testsuite/rust/compile/torture/traits10.rs this can be false - if (found_impl_trait) - lookup_associated->setup_associated_types (); - } // we can substitute the Self with the receiver here if (trait_item_tyty->get_kind () == TyTy::TypeKind::FNDEF) diff --git a/gcc/rust/typecheck/rust-hir-trait-ref.h b/gcc/rust/typecheck/rust-hir-trait-ref.h index a12736f..6eec461 100644 --- a/gcc/rust/typecheck/rust-hir-trait-ref.h +++ b/gcc/rust/typecheck/rust-hir-trait-ref.h @@ -454,18 +454,11 @@ public: TyTy::BaseType *get_self () { return self; } - void setup_associated_types (); - - void setup_associated_types2 (const TyTy::BaseType *self, - const TyTy::TypeBoundPredicate &bound); + void setup_associated_types (const TyTy::BaseType *self, + const TyTy::TypeBoundPredicate &bound); void reset_associated_types (); - TyTy::BaseType *get_projected_type (const TraitItemReference *trait_item_ref, - TyTy::BaseType *reciever, HirId ref, - HIR::GenericArgs &trait_generics, - Location expr_locus); - private: TraitReference *trait; HIR::ImplBlock *impl; diff --git a/gcc/rust/typecheck/rust-hir-trait-resolve.cc b/gcc/rust/typecheck/rust-hir-trait-resolve.cc index 5681ebd..13edd8d 100644 --- a/gcc/rust/typecheck/rust-hir-trait-resolve.cc +++ b/gcc/rust/typecheck/rust-hir-trait-resolve.cc @@ -61,8 +61,214 @@ ResolveTraitItemToRef::visit (HIR::TraitItemFunc &fn) self, std::move (substitutions), locus); } +ResolveTraitItemToRef::ResolveTraitItemToRef ( + TyTy::BaseType *self, + std::vector<TyTy::SubstitutionParamMapping> &&substitutions) + : TypeCheckBase (), resolved (TraitItemReference::error ()), self (self), + substitutions (std::move (substitutions)) +{} + // TraitItemReference items +TraitReference * +TraitResolver::Resolve (HIR::TypePath &path) +{ + TraitResolver resolver; + return resolver.resolve_path (path); +} + +TraitReference * +TraitResolver::Resolve (HIR::Trait &trait) +{ + TraitResolver resolver; + return resolver.resolve_trait (&trait); +} + +TraitReference * +TraitResolver::Lookup (HIR::TypePath &path) +{ + TraitResolver resolver; + return resolver.lookup_path (path); +} + +TraitResolver::TraitResolver () + : TypeCheckBase (), resolved_trait_reference (nullptr) +{} + +TraitReference * +TraitResolver::resolve_path (HIR::TypePath &path) +{ + NodeId ref; + if (!resolver->lookup_resolved_type (path.get_mappings ().get_nodeid (), + &ref)) + { + rust_error_at (path.get_locus (), "Failed to resolve path to node-id"); + return &TraitReference::error_node (); + } + + HirId hir_node = UNKNOWN_HIRID; + if (!mappings->lookup_node_to_hir (mappings->get_current_crate (), ref, + &hir_node)) + { + rust_error_at (path.get_locus (), "Failed to resolve path to hir-id"); + return &TraitReference::error_node (); + } + + HIR::Item *resolved_item + = mappings->lookup_hir_item (mappings->get_current_crate (), hir_node); + + rust_assert (resolved_item != nullptr); + resolved_item->accept_vis (*this); + rust_assert (resolved_trait_reference != nullptr); + + return resolve_trait (resolved_trait_reference); +} + +TraitReference * +TraitResolver::resolve_trait (HIR::Trait *trait_reference) +{ + TraitReference *tref = &TraitReference::error_node (); + if (context->lookup_trait_reference ( + trait_reference->get_mappings ().get_defid (), &tref)) + { + return tref; + } + + TyTy::BaseType *self = nullptr; + std::vector<TyTy::SubstitutionParamMapping> substitutions; + for (auto &generic_param : trait_reference->get_generic_params ()) + { + switch (generic_param.get ()->get_kind ()) + { + case HIR::GenericParam::GenericKind::LIFETIME: + // Skipping Lifetime completely until better handling. + break; + + case HIR::GenericParam::GenericKind::TYPE: { + auto param_type + = TypeResolveGenericParam::Resolve (generic_param.get ()); + context->insert_type (generic_param->get_mappings (), param_type); + + auto &typaram = static_cast<HIR::TypeParam &> (*generic_param); + substitutions.push_back ( + TyTy::SubstitutionParamMapping (typaram, param_type)); + + if (typaram.get_type_representation ().compare ("Self") == 0) + { + self = param_type; + } + } + break; + } + } + rust_assert (self != nullptr); + + // Check if there is a super-trait, and apply this bound to the Self + // TypeParam + std::vector<TyTy::TypeBoundPredicate> specified_bounds; + + // copy the substitition mappings + std::vector<TyTy::SubstitutionParamMapping> self_subst_copy; + for (auto &sub : substitutions) + self_subst_copy.push_back (sub.clone ()); + + // They also inherit themselves as a bound this enables a trait item to + // reference other Self::trait_items + auto self_hrtb + = TyTy::TypeBoundPredicate (trait_reference->get_mappings ().get_defid (), + std::move (self_subst_copy), + trait_reference->get_locus ()); + specified_bounds.push_back (self_hrtb); + + // look for any + std::vector<const TraitReference *> super_traits; + if (trait_reference->has_type_param_bounds ()) + { + for (auto &bound : trait_reference->get_type_param_bounds ()) + { + if (bound->get_bound_type () + == HIR::TypeParamBound::BoundType::TRAITBOUND) + { + HIR::TraitBound *b + = static_cast<HIR::TraitBound *> (bound.get ()); + + // FIXME this might be recursive we need a check for that + auto predicate = get_predicate_from_bound (b->get_path ()); + specified_bounds.push_back (predicate); + super_traits.push_back (predicate.get ()); + } + } + } + self->inherit_bounds (specified_bounds); + + std::vector<TraitItemReference> item_refs; + for (auto &item : trait_reference->get_trait_items ()) + { + // make a copy of the substs + std::vector<TyTy::SubstitutionParamMapping> item_subst; + for (auto &sub : substitutions) + item_subst.push_back (sub.clone ()); + + TraitItemReference trait_item_ref + = ResolveTraitItemToRef::Resolve (*item.get (), self, + std::move (item_subst)); + item_refs.push_back (std::move (trait_item_ref)); + } + + TraitReference trait_object (trait_reference, item_refs, + std::move (super_traits), + std::move (substitutions)); + context->insert_trait_reference ( + trait_reference->get_mappings ().get_defid (), std::move (trait_object)); + + tref = &TraitReference::error_node (); + bool ok = context->lookup_trait_reference ( + trait_reference->get_mappings ().get_defid (), &tref); + rust_assert (ok); + + // hook to allow the trait to resolve its optional item blocks, we cant + // resolve the blocks of functions etc because it can end up in a recursive + // loop of trying to resolve traits as required by the types + tref->on_resolved (); + + return tref; +} + +TraitReference * +TraitResolver::lookup_path (HIR::TypePath &path) +{ + NodeId ref; + if (!resolver->lookup_resolved_type (path.get_mappings ().get_nodeid (), + &ref)) + { + rust_error_at (path.get_locus (), "Failed to resolve path to node-id"); + return &TraitReference::error_node (); + } + + HirId hir_node = UNKNOWN_HIRID; + if (!mappings->lookup_node_to_hir (mappings->get_current_crate (), ref, + &hir_node)) + { + rust_error_at (path.get_locus (), "Failed to resolve path to hir-id"); + return &TraitReference::error_node (); + } + + HIR::Item *resolved_item + = mappings->lookup_hir_item (mappings->get_current_crate (), hir_node); + + rust_assert (resolved_item != nullptr); + resolved_item->accept_vis (*this); + rust_assert (resolved_trait_reference != nullptr); + + TraitReference *tref = &TraitReference::error_node (); + if (context->lookup_trait_reference ( + resolved_trait_reference->get_mappings ().get_defid (), &tref)) + { + return tref; + } + return &TraitReference::error_node (); +} + void TraitItemReference::on_resolved () { @@ -154,29 +360,7 @@ TraitItemReference::associated_type_reset () const } void -AssociatedImplTrait::setup_associated_types () -{ - ImplTypeIterator iter (*impl, [&] (HIR::TypeAlias &type) { - TraitItemReference *resolved_trait_item = nullptr; - bool ok = trait->lookup_trait_item (type.get_new_type_name (), - &resolved_trait_item); - if (!ok) - return; - if (resolved_trait_item->get_trait_item_type () - != TraitItemReference::TraitItemType::TYPE) - return; - - TyTy::BaseType *lookup; - if (!context->lookup_type (type.get_mappings ().get_hirid (), &lookup)) - return; - - resolved_trait_item->associated_type_set (lookup); - }); - iter.go (); -} - -void -AssociatedImplTrait::setup_associated_types2 ( +AssociatedImplTrait::setup_associated_types ( const TyTy::BaseType *self, const TyTy::TypeBoundPredicate &bound) { // compute the constrained impl block generic arguments based on self and the @@ -390,46 +574,6 @@ TraitItemReference::is_object_safe () const return false; } -TyTy::BaseType * -AssociatedImplTrait::get_projected_type ( - const TraitItemReference *trait_item_ref, TyTy::BaseType *receiver, HirId ref, - HIR::GenericArgs &trait_generics, Location expr_locus) -{ - TyTy::BaseType *trait_item_tyty = trait_item_ref->get_tyty ()->clone (); - - // we can substitute the Self with the receiver here - if (trait_item_tyty->get_kind () == TyTy::TypeKind::FNDEF) - { - TyTy::FnType *fn = static_cast<TyTy::FnType *> (trait_item_tyty); - TyTy::SubstitutionParamMapping *param = nullptr; - for (auto ¶m_mapping : fn->get_substs ()) - { - const HIR::TypeParam &type_param = param_mapping.get_generic_param (); - if (type_param.get_type_representation ().compare ("Self") == 0) - { - param = ¶m_mapping; - break; - } - } - rust_assert (param != nullptr); - - std::vector<TyTy::SubstitutionArg> mappings; - mappings.push_back (TyTy::SubstitutionArg (param, receiver->clone ())); - - TyTy::SubstitutionArgumentMappings args (std::move (mappings), - expr_locus); - trait_item_tyty = SubstMapperInternal::Resolve (trait_item_tyty, args); - } - - if (!trait_generics.is_empty ()) - { - trait_item_tyty - = SubstMapper::Resolve (trait_item_tyty, expr_locus, &trait_generics); - } - - return trait_item_tyty; -} - // rust-hir-path-probe.h void diff --git a/gcc/rust/typecheck/rust-hir-trait-resolve.h b/gcc/rust/typecheck/rust-hir-trait-resolve.h index 651af9d..a73b67f 100644 --- a/gcc/rust/typecheck/rust-hir-trait-resolve.h +++ b/gcc/rust/typecheck/rust-hir-trait-resolve.h @@ -52,10 +52,7 @@ public: private: ResolveTraitItemToRef ( TyTy::BaseType *self, - std::vector<TyTy::SubstitutionParamMapping> &&substitutions) - : TypeCheckBase (), resolved (TraitItemReference::error ()), self (self), - substitutions (std::move (substitutions)) - {} + std::vector<TyTy::SubstitutionParamMapping> &&substitutions); TraitItemReference resolved; TyTy::BaseType *self; @@ -67,191 +64,25 @@ class TraitResolver : public TypeCheckBase using Rust::Resolver::TypeCheckBase::visit; public: - static TraitReference *Resolve (HIR::TypePath &path) - { - TraitResolver resolver; - return resolver.go (path); - } - - static TraitReference *Lookup (HIR::TypePath &path) - { - TraitResolver resolver; - return resolver.lookup_path (path); - } - -private: - TraitResolver () : TypeCheckBase () {} - - TraitReference *go (HIR::TypePath &path) - { - NodeId ref; - if (!resolver->lookup_resolved_type (path.get_mappings ().get_nodeid (), - &ref)) - { - rust_error_at (path.get_locus (), "Failed to resolve path to node-id"); - return &TraitReference::error_node (); - } - - HirId hir_node = UNKNOWN_HIRID; - if (!mappings->lookup_node_to_hir (mappings->get_current_crate (), ref, - &hir_node)) - { - rust_error_at (path.get_locus (), "Failed to resolve path to hir-id"); - return &TraitReference::error_node (); - } - - HIR::Item *resolved_item - = mappings->lookup_hir_item (mappings->get_current_crate (), hir_node); - - rust_assert (resolved_item != nullptr); - resolved_item->accept_vis (*this); - rust_assert (trait_reference != nullptr); - - TraitReference *tref = &TraitReference::error_node (); - if (context->lookup_trait_reference ( - trait_reference->get_mappings ().get_defid (), &tref)) - { - return tref; - } - - TyTy::BaseType *self = nullptr; - std::vector<TyTy::SubstitutionParamMapping> substitutions; - for (auto &generic_param : trait_reference->get_generic_params ()) - { - switch (generic_param.get ()->get_kind ()) - { - case HIR::GenericParam::GenericKind::LIFETIME: - // Skipping Lifetime completely until better handling. - break; - - case HIR::GenericParam::GenericKind::TYPE: { - auto param_type - = TypeResolveGenericParam::Resolve (generic_param.get ()); - context->insert_type (generic_param->get_mappings (), param_type); - - auto &typaram = static_cast<HIR::TypeParam &> (*generic_param); - substitutions.push_back ( - TyTy::SubstitutionParamMapping (typaram, param_type)); + static TraitReference *Resolve (HIR::TypePath &path); - if (typaram.get_type_representation ().compare ("Self") == 0) - { - self = param_type; - } - } - break; - } - } - rust_assert (self != nullptr); + static TraitReference *Resolve (HIR::Trait &trait); - // Check if there is a super-trait, and apply this bound to the Self - // TypeParam - std::vector<TyTy::TypeBoundPredicate> specified_bounds; + static TraitReference *Lookup (HIR::TypePath &path); - // copy the substitition mappings - std::vector<TyTy::SubstitutionParamMapping> self_subst_copy; - for (auto &sub : substitutions) - self_subst_copy.push_back (sub.clone ()); - - // They also inherit themselves as a bound this enables a trait item to - // reference other Self::trait_items - auto self_hrtb - = TyTy::TypeBoundPredicate (trait_reference->get_mappings ().get_defid (), - std::move (self_subst_copy), - trait_reference->get_locus ()); - specified_bounds.push_back (self_hrtb); - - // look for any - std::vector<const TraitReference *> super_traits; - if (trait_reference->has_type_param_bounds ()) - { - for (auto &bound : trait_reference->get_type_param_bounds ()) - { - if (bound->get_bound_type () - == HIR::TypeParamBound::BoundType::TRAITBOUND) - { - HIR::TraitBound *b - = static_cast<HIR::TraitBound *> (bound.get ()); - - // FIXME this might be recursive we need a check for that - auto predicate = get_predicate_from_bound (b->get_path ()); - specified_bounds.push_back (predicate); - super_traits.push_back (predicate.get ()); - } - } - } - self->inherit_bounds (specified_bounds); - - std::vector<TraitItemReference> item_refs; - for (auto &item : trait_reference->get_trait_items ()) - { - // make a copy of the substs - std::vector<TyTy::SubstitutionParamMapping> item_subst; - for (auto &sub : substitutions) - item_subst.push_back (sub.clone ()); - - TraitItemReference trait_item_ref - = ResolveTraitItemToRef::Resolve (*item.get (), self, - std::move (item_subst)); - item_refs.push_back (std::move (trait_item_ref)); - } - - TraitReference trait_object (trait_reference, item_refs, - std::move (super_traits), - std::move (substitutions)); - context->insert_trait_reference ( - trait_reference->get_mappings ().get_defid (), std::move (trait_object)); - - tref = &TraitReference::error_node (); - bool ok = context->lookup_trait_reference ( - trait_reference->get_mappings ().get_defid (), &tref); - rust_assert (ok); - - // hook to allow the trait to resolve its optional item blocks, we cant - // resolve the blocks of functions etc because it can end up in a recursive - // loop of trying to resolve traits as required by the types - tref->on_resolved (); - - return tref; - } - - TraitReference *lookup_path (HIR::TypePath &path) - { - NodeId ref; - if (!resolver->lookup_resolved_type (path.get_mappings ().get_nodeid (), - &ref)) - { - rust_error_at (path.get_locus (), "Failed to resolve path to node-id"); - return &TraitReference::error_node (); - } - - HirId hir_node = UNKNOWN_HIRID; - if (!mappings->lookup_node_to_hir (mappings->get_current_crate (), ref, - &hir_node)) - { - rust_error_at (path.get_locus (), "Failed to resolve path to hir-id"); - return &TraitReference::error_node (); - } +private: + TraitResolver (); - HIR::Item *resolved_item - = mappings->lookup_hir_item (mappings->get_current_crate (), hir_node); + TraitReference *resolve_path (HIR::TypePath &path); - rust_assert (resolved_item != nullptr); - resolved_item->accept_vis (*this); - rust_assert (trait_reference != nullptr); + TraitReference *resolve_trait (HIR::Trait *trait_reference); - TraitReference *tref = &TraitReference::error_node (); - if (context->lookup_trait_reference ( - trait_reference->get_mappings ().get_defid (), &tref)) - { - return tref; - } - return &TraitReference::error_node (); - } + TraitReference *lookup_path (HIR::TypePath &path); - HIR::Trait *trait_reference; + HIR::Trait *resolved_trait_reference; public: - void visit (HIR::Trait &trait) override { trait_reference = &trait; } + void visit (HIR::Trait &trait) override { resolved_trait_reference = &trait; } }; } // namespace Resolver diff --git a/gcc/rust/typecheck/rust-hir-type-check-item.h b/gcc/rust/typecheck/rust-hir-type-check-item.h index 9d3beae..71b6b81 100644 --- a/gcc/rust/typecheck/rust-hir-type-check-item.h +++ b/gcc/rust/typecheck/rust-hir-type-check-item.h @@ -224,6 +224,8 @@ public: TypeCheckItem::Resolve (item.get ()); } + void visit (HIR::Trait &trait) override { TraitResolver::Resolve (trait); } + private: TypeCheckItem () : TypeCheckBase () {} }; diff --git a/gcc/rust/typecheck/rust-hir-type-check-path.cc b/gcc/rust/typecheck/rust-hir-type-check-path.cc index 9960e76..3823c57 100644 --- a/gcc/rust/typecheck/rust-hir-type-check-path.cc +++ b/gcc/rust/typecheck/rust-hir-type-check-path.cc @@ -67,41 +67,41 @@ TypeCheckExpr::visit (HIR::QualifiedPathInExpression &expr) // inherit the bound root->inherit_bounds ({specified_bound}); - // we need resolve to the impl block - NodeId impl_resolved_id = UNKNOWN_NODEID; - bool ok = resolver->lookup_resolved_name ( - qual_path_type.get_mappings ().get_nodeid (), &impl_resolved_id); - rust_assert (ok); - - HirId impl_block_id; - ok = mappings->lookup_node_to_hir (expr.get_mappings ().get_crate_num (), - impl_resolved_id, &impl_block_id); - rust_assert (ok); - - AssociatedImplTrait *lookup_associated = nullptr; - bool found_impl_trait - = context->lookup_associated_trait_impl (impl_block_id, &lookup_associated); - rust_assert (found_impl_trait); - + // lookup the associated item from the specified bound HIR::PathExprSegment &item_seg = expr.get_segments ().at (0); - - const TraitItemReference *trait_item_ref = nullptr; - ok = trait_ref->lookup_trait_item (item_seg.get_segment ().as_string (), - &trait_item_ref); - if (!ok) + HIR::PathIdentSegment item_seg_identifier = item_seg.get_segment (); + TyTy::TypeBoundPredicateItem item + = specified_bound.lookup_associated_item (item_seg_identifier.as_string ()); + if (item.is_error ()) { rust_error_at (item_seg.get_locus (), "unknown associated item"); return; } - HIR::GenericArgs trait_generics = qual_path_type.trait_has_generic_args () - ? qual_path_type.get_trait_generic_args () - : HIR::GenericArgs::create_empty (); + // infer the root type + infered = item.get_tyty_for_receiver (root); - lookup_associated->setup_associated_types (); - infered = lookup_associated->get_projected_type ( - trait_item_ref, root, item_seg.get_mappings ().get_hirid (), trait_generics, - item_seg.get_locus ()); + // we need resolve to the impl block + NodeId impl_resolved_id = UNKNOWN_NODEID; + bool have_associated_impl = resolver->lookup_resolved_name ( + qual_path_type.get_mappings ().get_nodeid (), &impl_resolved_id); + AssociatedImplTrait *lookup_associated = nullptr; + if (have_associated_impl) + { + HirId impl_block_id; + bool ok + = mappings->lookup_node_to_hir (expr.get_mappings ().get_crate_num (), + impl_resolved_id, &impl_block_id); + rust_assert (ok); + + bool found_impl_trait + = context->lookup_associated_trait_impl (impl_block_id, + &lookup_associated); + if (found_impl_trait) + { + lookup_associated->setup_associated_types (root, specified_bound); + } + } // turbo-fish segment path::<ty> if (item_seg.has_generic_args ()) @@ -119,6 +119,7 @@ TypeCheckExpr::visit (HIR::QualifiedPathInExpression &expr) } // continue on as a path-in-expression + const TraitItemReference *trait_item_ref = item.get_raw_item (); NodeId root_resolved_node_id = trait_item_ref->get_mappings ().get_nodeid (); bool fully_resolved = expr.get_segments ().size () <= 1; @@ -348,20 +349,6 @@ TypeCheckExpr::resolve_segments (NodeId root_resolved_node_id, HIR::ImplBlock *impl = candidate.item.trait.impl; if (impl != nullptr) { - AssociatedImplTrait *lookup_associated = nullptr; - bool found_impl_trait = context->lookup_associated_trait_impl ( - impl->get_mappings ().get_hirid (), &lookup_associated); - - // setup associated mappings if possible we might be resolving a - // path within a default implementation of a trait function - // see: testsuite/rust/compile/torture/traits16.rs - if (found_impl_trait) - lookup_associated->setup_associated_types (); - - // we need a new ty_ref_id for this trait item - tyseg = tyseg->clone (); - tyseg->set_ty_ref (mappings->get_next_hir_id ()); - // get the associated impl block associated_impl_block = impl; } diff --git a/gcc/rust/typecheck/rust-hir-type-check-type.cc b/gcc/rust/typecheck/rust-hir-type-check-type.cc index 914bebb..bd40344 100644 --- a/gcc/rust/typecheck/rust-hir-type-check-type.cc +++ b/gcc/rust/typecheck/rust-hir-type-check-type.cc @@ -142,31 +142,35 @@ TypeCheckType::visit (HIR::QualifiedPathInType &path) return; } + // get the predicate for the bound + auto specified_bound + = get_predicate_from_bound (*qual_path_type.get_trait ().get ()); + if (specified_bound.is_error ()) + return; + + // inherit the bound + root->inherit_bounds ({specified_bound}); + + // lookup the associated item from the specified bound std::unique_ptr<HIR::TypePathSegment> &item_seg = path.get_associated_segment (); - const TraitItemReference *trait_item_ref = nullptr; - bool ok - = trait_ref->lookup_trait_item (item_seg->get_ident_segment ().as_string (), - &trait_item_ref); - if (!ok) + HIR::PathIdentSegment item_seg_identifier = item_seg->get_ident_segment (); + TyTy::TypeBoundPredicateItem item + = specified_bound.lookup_associated_item (item_seg_identifier.as_string ()); + if (item.is_error ()) { rust_error_at (item_seg->get_locus (), "unknown associated item"); return; } - // this will be the placeholder from the trait but we may be able to project - // it based on the impl block - translated = trait_item_ref->get_tyty (); - - // this is the associated generics we need to potentially apply - HIR::GenericArgs trait_generics = qual_path_type.trait_has_generic_args () - ? qual_path_type.get_trait_generic_args () - : HIR::GenericArgs::create_empty (); + // infer the root type + translated = item.get_tyty_for_receiver (root); // we need resolve to the impl block NodeId impl_resolved_id = UNKNOWN_NODEID; bool have_associated_impl = resolver->lookup_resolved_name ( qual_path_type.get_mappings ().get_nodeid (), &impl_resolved_id); + AssociatedImplTrait *lookup_associated = nullptr; if (have_associated_impl) { HirId impl_block_id; @@ -175,30 +179,16 @@ TypeCheckType::visit (HIR::QualifiedPathInType &path) impl_resolved_id, &impl_block_id); rust_assert (ok); - AssociatedImplTrait *lookup_associated = nullptr; bool found_impl_trait = context->lookup_associated_trait_impl (impl_block_id, &lookup_associated); - rust_assert (found_impl_trait); - - // project - lookup_associated->setup_associated_types (); - translated = lookup_associated->get_projected_type ( - trait_item_ref, root, item_seg->get_mappings ().get_hirid (), - trait_generics, item_seg->get_locus ()); - } - - if (translated->get_kind () == TyTy::TypeKind::PLACEHOLDER) - { - // lets grab the actual projection type - TyTy::PlaceholderType *p - = static_cast<TyTy::PlaceholderType *> (translated); - if (p->can_resolve ()) + if (found_impl_trait) { - translated = p->resolve (); + lookup_associated->setup_associated_types (root, specified_bound); } } + // turbo-fish segment path::<ty> if (item_seg->get_type () == HIR::TypePathSegment::SegmentType::GENERIC) { HIR::TypePathSegmentGeneric &generic_seg @@ -222,6 +212,7 @@ TypeCheckType::visit (HIR::QualifiedPathInType &path) } // continue on as a path-in-expression + const TraitItemReference *trait_item_ref = item.get_raw_item (); NodeId root_resolved_node_id = trait_item_ref->get_mappings ().get_nodeid (); bool fully_resolved = path.get_segments ().empty (); if (fully_resolved) @@ -448,22 +439,6 @@ TypeCheckType::resolve_segments ( { resolved_node_id = candidate.item.trait.item_ref->get_mappings ().get_nodeid (); - - // lookup the associated-impl-trait - HIR::ImplBlock *impl = candidate.item.trait.impl; - if (impl != nullptr && !reciever_is_generic) - { - AssociatedImplTrait *lookup_associated = nullptr; - bool found_impl_trait = context->lookup_associated_trait_impl ( - impl->get_mappings ().get_hirid (), &lookup_associated); - rust_assert (found_impl_trait); - - lookup_associated->setup_associated_types (); - - // we need a new ty_ref_id for this trait item - tyseg = tyseg->clone (); - tyseg->set_ty_ref (mappings->get_next_hir_id ()); - } } if (seg->is_generic_segment ()) diff --git a/gcc/rust/typecheck/rust-tyty.cc b/gcc/rust/typecheck/rust-tyty.cc index 847ca88..7302b06 100644 --- a/gcc/rust/typecheck/rust-tyty.cc +++ b/gcc/rust/typecheck/rust-tyty.cc @@ -826,22 +826,23 @@ SubstitutionRef::monomorphize () bool found_impl_trait = context->lookup_associated_trait_impl (impl_block_id, &associated); - rust_assert (found_impl_trait); - - bool found_trait - = specified_bound_ref->is_equal (*bound_trait_ref); - bool found_self - = associated->get_self ()->can_eq (binding, false); - if (found_trait && found_self) + if (found_impl_trait) { - associated_impl_trait = associated; - break; + bool found_trait + = specified_bound_ref->is_equal (*bound_trait_ref); + bool found_self + = associated->get_self ()->can_eq (binding, false); + if (found_trait && found_self) + { + associated_impl_trait = associated; + break; + } } } if (associated_impl_trait != nullptr) { - associated_impl_trait->setup_associated_types2 (binding, bound); + associated_impl_trait->setup_associated_types (binding, bound); } } } @@ -1230,6 +1231,19 @@ FnType::is_equal (const BaseType &other) const { if (get_num_substitutions () != other2.get_num_substitutions ()) return false; + + const FnType &ofn = static_cast<const FnType &> (other); + for (size_t i = 0; i < get_num_substitutions (); i++) + { + const SubstitutionParamMapping &a = get_substs ().at (i); + const SubstitutionParamMapping &b = ofn.get_substs ().at (i); + + const ParamType *pa = a.get_param_ty (); + const ParamType *pb = b.get_param_ty (); + + if (!pa->is_equal (*pb)) + return false; + } } if (num_params () != other2.num_params ()) @@ -2961,6 +2975,7 @@ TypeCheckCallExpr::visit (ADTType &type) void TypeCheckCallExpr::visit (FnType &type) { + type.monomorphize (); if (call.num_params () != type.num_params ()) { if (type.is_varadic ()) diff --git a/gcc/testsuite/rust/compile/issue-1128.rs b/gcc/testsuite/rust/compile/issue-1128.rs new file mode 100644 index 0000000..462426b --- /dev/null +++ b/gcc/testsuite/rust/compile/issue-1128.rs @@ -0,0 +1,6 @@ +pub trait Hasher { + fn write(&mut self, bytes: &[u8]); + fn write_u8(&mut self, i: u8) { + self.write(&[i]) + } +} diff --git a/gcc/testsuite/rust/compile/pub_restricted_1.rs b/gcc/testsuite/rust/compile/pub_restricted_1.rs new file mode 100644 index 0000000..01fb65e --- /dev/null +++ b/gcc/testsuite/rust/compile/pub_restricted_1.rs @@ -0,0 +1,14 @@ +pub mod foo { + pub mod bar { + pub fn baz() {} + } +} + +// this is invalid Rust: We just want to make sure the paths get resolved properly +pub(in foo::bar::baz) struct A0; + +pub(in foo::fah::baz) struct A1; // { dg-error "cannot find simple path segment .fah." } +pub(in fro::bulator::saindoux) struct A2; // { dg-error "cannot find simple path segment .fro." } +pub(in foo::bar::saindoux) struct A3; // { dg-error "cannot find simple path segment .saindoux." } + +fn main() {} |