From 16a1e8af9d848cb9864cb30476a6ed444538ecba Mon Sep 17 00:00:00 2001 From: Philip Herron Date: Mon, 20 Apr 2020 18:47:22 +0100 Subject: This setups an initial frame work for our resolution step for the pipeline More work is required but it takes advantage of the vistior pattern from the AST so we can do this without RTTI and dynamic_casts. More passes on the AST AKA our HIR should follow this pattern. Addresses: #12 --- gcc/rust/analysis/rust-resolution.cc | 605 +++++++++++++++++++++++++++++++++++ gcc/rust/analysis/rust-resolution.h | 235 ++++++++++++++ gcc/rust/analysis/scope.h | 55 ++++ 3 files changed, 895 insertions(+) create mode 100644 gcc/rust/analysis/rust-resolution.cc create mode 100644 gcc/rust/analysis/rust-resolution.h create mode 100644 gcc/rust/analysis/scope.h (limited to 'gcc/rust/analysis') diff --git a/gcc/rust/analysis/rust-resolution.cc b/gcc/rust/analysis/rust-resolution.cc new file mode 100644 index 0000000..65fed90 --- /dev/null +++ b/gcc/rust/analysis/rust-resolution.cc @@ -0,0 +1,605 @@ +#include "rust-resolution.h" + +namespace Rust { +namespace Analysis { + +TypeResolution::TypeResolution (AST::Crate &crate) : scope (), crate (crate) {} + +TypeResolution::~TypeResolution () {} + +bool +TypeResolution::ResolveNamesAndTypes (AST::Crate &crate) +{ + TypeResolution resolver (crate); + return resolver.go (); +} + +bool +TypeResolution::go () +{ + scope.Push (); + for (auto &item : crate.items) + { + item->accept_vis (*this); + } + scope.Pop (); + return true; +} + +void +TypeResolution::visit (AST::Token &tok) +{} + +void +TypeResolution::visit (AST::DelimTokenTree &delim_tok_tree) +{} + +void +TypeResolution::visit (AST::AttrInputMetaItemContainer &input) +{} + +void +TypeResolution::visit (AST::IdentifierExpr &ident_expr) +{} + +void +TypeResolution::visit (AST::Lifetime &lifetime) +{} + +void +TypeResolution::visit (AST::LifetimeParam &lifetime_param) +{} + +void +TypeResolution::visit (AST::MacroInvocationSemi ¯o) +{} + +// rust-path.h +void +TypeResolution::visit (AST::PathInExpression &path) +{} +void +TypeResolution::visit (AST::TypePathSegment &segment) +{} +void +TypeResolution::visit (AST::TypePathSegmentGeneric &segment) +{} +void +TypeResolution::visit (AST::TypePathSegmentFunction &segment) +{} +void +TypeResolution::visit (AST::TypePath &path) +{} +void +TypeResolution::visit (AST::QualifiedPathInExpression &path) +{} +void +TypeResolution::visit (AST::QualifiedPathInType &path) +{} + +// rust-expr.h +void +TypeResolution::visit (AST::LiteralExpr &expr) +{} +void +TypeResolution::visit (AST::AttrInputLiteral &attr_input) +{} +void +TypeResolution::visit (AST::MetaItemLitExpr &meta_item) +{} +void +TypeResolution::visit (AST::MetaItemPathLit &meta_item) +{} +void +TypeResolution::visit (AST::BorrowExpr &expr) +{} +void +TypeResolution::visit (AST::DereferenceExpr &expr) +{} +void +TypeResolution::visit (AST::ErrorPropagationExpr &expr) +{} +void +TypeResolution::visit (AST::NegationExpr &expr) +{} +void +TypeResolution::visit (AST::ArithmeticOrLogicalExpr &expr) +{} +void +TypeResolution::visit (AST::ComparisonExpr &expr) +{} +void +TypeResolution::visit (AST::LazyBooleanExpr &expr) +{} +void +TypeResolution::visit (AST::TypeCastExpr &expr) +{} +void +TypeResolution::visit (AST::AssignmentExpr &expr) +{} +void +TypeResolution::visit (AST::CompoundAssignmentExpr &expr) +{} +void +TypeResolution::visit (AST::GroupedExpr &expr) +{} +// void TypeResolution::visit(ArrayElems& elems) {} +void +TypeResolution::visit (AST::ArrayElemsValues &elems) +{} +void +TypeResolution::visit (AST::ArrayElemsCopied &elems) +{} +void +TypeResolution::visit (AST::ArrayExpr &expr) +{} +void +TypeResolution::visit (AST::ArrayIndexExpr &expr) +{} +void +TypeResolution::visit (AST::TupleExpr &expr) +{} +void +TypeResolution::visit (AST::TupleIndexExpr &expr) +{} +void +TypeResolution::visit (AST::StructExprStruct &expr) +{} +// void TypeResolution::visit(StructExprField& field) {} +void +TypeResolution::visit (AST::StructExprFieldIdentifier &field) +{} +void +TypeResolution::visit (AST::StructExprFieldIdentifierValue &field) +{} +void +TypeResolution::visit (AST::StructExprFieldIndexValue &field) +{} +void +TypeResolution::visit (AST::StructExprStructFields &expr) +{} +void +TypeResolution::visit (AST::StructExprStructBase &expr) +{} +void +TypeResolution::visit (AST::StructExprTuple &expr) +{} +void +TypeResolution::visit (AST::StructExprUnit &expr) +{} +// void TypeResolution::visit(EnumExprField& field) {} +void +TypeResolution::visit (AST::EnumExprFieldIdentifier &field) +{} +void +TypeResolution::visit (AST::EnumExprFieldIdentifierValue &field) +{} +void +TypeResolution::visit (AST::EnumExprFieldIndexValue &field) +{} +void +TypeResolution::visit (AST::EnumExprStruct &expr) +{} +void +TypeResolution::visit (AST::EnumExprTuple &expr) +{} +void +TypeResolution::visit (AST::EnumExprFieldless &expr) +{} +void +TypeResolution::visit (AST::CallExpr &expr) +{} +void +TypeResolution::visit (AST::MethodCallExpr &expr) +{} +void +TypeResolution::visit (AST::FieldAccessExpr &expr) +{} +void +TypeResolution::visit (AST::ClosureExprInner &expr) +{} +void +TypeResolution::visit (AST::BlockExpr &expr) +{} +void +TypeResolution::visit (AST::ClosureExprInnerTyped &expr) +{} +void +TypeResolution::visit (AST::ContinueExpr &expr) +{} +void +TypeResolution::visit (AST::BreakExpr &expr) +{} +void +TypeResolution::visit (AST::RangeFromToExpr &expr) +{} +void +TypeResolution::visit (AST::RangeFromExpr &expr) +{} +void +TypeResolution::visit (AST::RangeToExpr &expr) +{} +void +TypeResolution::visit (AST::RangeFullExpr &expr) +{} +void +TypeResolution::visit (AST::RangeFromToInclExpr &expr) +{} +void +TypeResolution::visit (AST::RangeToInclExpr &expr) +{} +void +TypeResolution::visit (AST::ReturnExpr &expr) +{} +void +TypeResolution::visit (AST::UnsafeBlockExpr &expr) +{} +void +TypeResolution::visit (AST::LoopExpr &expr) +{} +void +TypeResolution::visit (AST::WhileLoopExpr &expr) +{} +void +TypeResolution::visit (AST::WhileLetLoopExpr &expr) +{} +void +TypeResolution::visit (AST::ForLoopExpr &expr) +{} +void +TypeResolution::visit (AST::IfExpr &expr) +{} +void +TypeResolution::visit (AST::IfExprConseqElse &expr) +{} +void +TypeResolution::visit (AST::IfExprConseqIf &expr) +{} +void +TypeResolution::visit (AST::IfExprConseqIfLet &expr) +{} +void +TypeResolution::visit (AST::IfLetExpr &expr) +{} +void +TypeResolution::visit (AST::IfLetExprConseqElse &expr) +{} +void +TypeResolution::visit (AST::IfLetExprConseqIf &expr) +{} +void +TypeResolution::visit (AST::IfLetExprConseqIfLet &expr) +{} +// void TypeResolution::visit(MatchCase& match_case) {} +void +TypeResolution::visit (AST::MatchCaseBlockExpr &match_case) +{} +void +TypeResolution::visit (AST::MatchCaseExpr &match_case) +{} +void +TypeResolution::visit (AST::MatchExpr &expr) +{} +void +TypeResolution::visit (AST::AwaitExpr &expr) +{} +void +TypeResolution::visit (AST::AsyncBlockExpr &expr) +{} + +// rust-item.h +void +TypeResolution::visit (AST::TypeParam ¶m) +{} +// void TypeResolution::visit(WhereClauseItem& item) {} +void +TypeResolution::visit (AST::LifetimeWhereClauseItem &item) +{} +void +TypeResolution::visit (AST::TypeBoundWhereClauseItem &item) +{} +void +TypeResolution::visit (AST::Method &method) +{} +void +TypeResolution::visit (AST::ModuleBodied &module) +{} +void +TypeResolution::visit (AST::ModuleNoBody &module) +{} +void +TypeResolution::visit (AST::ExternCrate &crate) +{} +// void TypeResolution::visit(UseTree& use_tree) {} +void +TypeResolution::visit (AST::UseTreeGlob &use_tree) +{} +void +TypeResolution::visit (AST::UseTreeList &use_tree) +{} +void +TypeResolution::visit (AST::UseTreeRebind &use_tree) +{} +void +TypeResolution::visit (AST::UseDeclaration &use_decl) +{} + +void +TypeResolution::visit (AST::Function &function) +{ + scope.Insert (function.function_name, function.return_type.get ()); + + scope.Push (); + printf ("INSIDE FUNCTION: %s\n", function.function_name.c_str ()); + + for (auto ¶m : function.function_params) + { + printf ("FUNC PARAM: %s\n", param.as_string ().c_str ()); + } + + // ensure return types + // TODO + + // walk the expression body + for (auto &stmt : function.function_body->statements) + { + stmt->accept_vis (*this); + } + + scope.Pop (); +} + +void +TypeResolution::visit (AST::TypeAlias &type_alias) +{} +void +TypeResolution::visit (AST::StructStruct &struct_item) +{} +void +TypeResolution::visit (AST::TupleStruct &tuple_struct) +{} +void +TypeResolution::visit (AST::EnumItem &item) +{} +void +TypeResolution::visit (AST::EnumItemTuple &item) +{} +void +TypeResolution::visit (AST::EnumItemStruct &item) +{} +void +TypeResolution::visit (AST::EnumItemDiscriminant &item) +{} +void +TypeResolution::visit (AST::Enum &enum_item) +{} +void +TypeResolution::visit (AST::Union &union_item) +{} +void +TypeResolution::visit (AST::ConstantItem &const_item) +{} +void +TypeResolution::visit (AST::StaticItem &static_item) +{} +void +TypeResolution::visit (AST::TraitItemFunc &item) +{} +void +TypeResolution::visit (AST::TraitItemMethod &item) +{} +void +TypeResolution::visit (AST::TraitItemConst &item) +{} +void +TypeResolution::visit (AST::TraitItemType &item) +{} +void +TypeResolution::visit (AST::Trait &trait) +{} +void +TypeResolution::visit (AST::InherentImpl &impl) +{} +void +TypeResolution::visit (AST::TraitImpl &impl) +{} +// void TypeResolution::visit(ExternalItem& item) {} +void +TypeResolution::visit (AST::ExternalStaticItem &item) +{} +void +TypeResolution::visit (AST::ExternalFunctionItem &item) +{} +void +TypeResolution::visit (AST::ExternBlock &block) +{} + +// rust-macro.h +void +TypeResolution::visit (AST::MacroMatchFragment &match) +{} +void +TypeResolution::visit (AST::MacroMatchRepetition &match) +{} +void +TypeResolution::visit (AST::MacroMatcher &matcher) +{} +void +TypeResolution::visit (AST::MacroRulesDefinition &rules_def) +{} +void +TypeResolution::visit (AST::MacroInvocation ¯o_invoc) +{} +void +TypeResolution::visit (AST::MetaItemPath &meta_item) +{} +void +TypeResolution::visit (AST::MetaItemSeq &meta_item) +{} +void +TypeResolution::visit (AST::MetaWord &meta_item) +{} +void +TypeResolution::visit (AST::MetaNameValueStr &meta_item) +{} +void +TypeResolution::visit (AST::MetaListPaths &meta_item) +{} +void +TypeResolution::visit (AST::MetaListNameValueStr &meta_item) +{} + +// rust-pattern.h +void +TypeResolution::visit (AST::LiteralPattern &pattern) +{ + printf ("LiteralPattern: %s\n", pattern.as_string ().c_str ()); +} + +void +TypeResolution::visit (AST::IdentifierPattern &pattern) +{ + printf ("IdentifierPattern: %s\n", pattern.as_string ().c_str ()); + letPatternBuffer.push_back (pattern); +} + +void +TypeResolution::visit (AST::WildcardPattern &pattern) +{} +// void TypeResolution::visit(RangePatternBound& bound) {} +void +TypeResolution::visit (AST::RangePatternBoundLiteral &bound) +{} +void +TypeResolution::visit (AST::RangePatternBoundPath &bound) +{} +void +TypeResolution::visit (AST::RangePatternBoundQualPath &bound) +{} +void +TypeResolution::visit (AST::RangePattern &pattern) +{} +void +TypeResolution::visit (AST::ReferencePattern &pattern) +{} +// void TypeResolution::visit(StructPatternField& field) {} +void +TypeResolution::visit (AST::StructPatternFieldTuplePat &field) +{} +void +TypeResolution::visit (AST::StructPatternFieldIdentPat &field) +{} +void +TypeResolution::visit (AST::StructPatternFieldIdent &field) +{} +void +TypeResolution::visit (AST::StructPattern &pattern) +{} +// void TypeResolution::visit(TupleStructItems& tuple_items) {} +void +TypeResolution::visit (AST::TupleStructItemsNoRange &tuple_items) +{} +void +TypeResolution::visit (AST::TupleStructItemsRange &tuple_items) +{} +void +TypeResolution::visit (AST::TupleStructPattern &pattern) +{} +// void TypeResolution::visit(TuplePatternItems& tuple_items) {} +void +TypeResolution::visit (AST::TuplePatternItemsMultiple &tuple_items) +{} +void +TypeResolution::visit (AST::TuplePatternItemsRanged &tuple_items) +{} +void +TypeResolution::visit (AST::TuplePattern &pattern) +{} +void +TypeResolution::visit (AST::GroupedPattern &pattern) +{} +void +TypeResolution::visit (AST::SlicePattern &pattern) +{} + +// rust-stmt.h +void +TypeResolution::visit (AST::EmptyStmt &stmt) +{} +void + +TypeResolution::visit (AST::LetStmt &stmt) +{ + printf ("Within LetStmt: %s\n", stmt.as_string ().c_str ()); + + if (!stmt.has_type ()) + { + // infer the type + printf ("XXX UNKNOWN TYPE PLEASE INFER ME\n"); + } + + // TODO check we know what the type is + + stmt.variables_pattern->accept_vis (*this); + + for (auto it = letPatternBuffer.begin (); it != letPatternBuffer.end (); it++) + { + scope.Insert (it->variable_ident, stmt.type.get ()); + } + + letPatternBuffer.clear (); +} + +void +TypeResolution::visit (AST::ExprStmtWithoutBlock &stmt) +{} +void +TypeResolution::visit (AST::ExprStmtWithBlock &stmt) +{} + +// rust-type.h +void +TypeResolution::visit (AST::TraitBound &bound) +{} +void +TypeResolution::visit (AST::ImplTraitType &type) +{} +void +TypeResolution::visit (AST::TraitObjectType &type) +{} +void +TypeResolution::visit (AST::ParenthesisedType &type) +{} +void +TypeResolution::visit (AST::ImplTraitTypeOneBound &type) +{} +void +TypeResolution::visit (AST::TraitObjectTypeOneBound &type) +{} +void +TypeResolution::visit (AST::TupleType &type) +{} +void +TypeResolution::visit (AST::NeverType &type) +{} +void +TypeResolution::visit (AST::RawPointerType &type) +{} +void +TypeResolution::visit (AST::ReferenceType &type) +{} +void +TypeResolution::visit (AST::ArrayType &type) +{} +void +TypeResolution::visit (AST::SliceType &type) +{} +void +TypeResolution::visit (AST::InferredType &type) +{} +void +TypeResolution::visit (AST::BareFunctionType &type) +{} + +} // namespace Analysis +} // namespace Rust diff --git a/gcc/rust/analysis/rust-resolution.h b/gcc/rust/analysis/rust-resolution.h new file mode 100644 index 0000000..940557e --- /dev/null +++ b/gcc/rust/analysis/rust-resolution.h @@ -0,0 +1,235 @@ +#pragma once + +#include "rust-system.h" +#include "rust-ast-full.h" +#include "rust-ast-visitor.h" +#include "scope.h" + +namespace Rust { +namespace Analysis { + +class TypeResolution : public AST::ASTVisitor +{ +public: + static bool ResolveNamesAndTypes (AST::Crate &crate); + + ~TypeResolution (); + + // visitor impl + // rust-ast.h + // virtual void visit(AttrInput& attr_input); + // virtual void visit(TokenTree& token_tree); + // virtual void visit(MacroMatch& macro_match); + virtual void visit (AST::Token &tok); + virtual void visit (AST::DelimTokenTree &delim_tok_tree); + virtual void visit (AST::AttrInputMetaItemContainer &input); + // virtual void visit(MetaItem& meta_item); + // virtual void vsit(Stmt& stmt); + // virtual void visit(Expr& expr); + virtual void visit (AST::IdentifierExpr &ident_expr); + // virtual void visit(Pattern& pattern); + // virtual void visit(Type& type); + // virtual void visit(TypeParamBound& type_param_bound); + virtual void visit (AST::Lifetime &lifetime); + // virtual void visit(GenericParam& generic_param); + virtual void visit (AST::LifetimeParam &lifetime_param); + // virtual void visit(TraitItem& trait_item); + // virtual void visit(InherentImplItem& inherent_impl_item); + // virtual void visit(TraitImplItem& trait_impl_item); + virtual void visit (AST::MacroInvocationSemi ¯o); + + // rust-path.h + virtual void visit (AST::PathInExpression &path); + virtual void visit (AST::TypePathSegment &segment); + virtual void visit (AST::TypePathSegmentGeneric &segment); + virtual void visit (AST::TypePathSegmentFunction &segment); + virtual void visit (AST::TypePath &path); + virtual void visit (AST::QualifiedPathInExpression &path); + virtual void visit (AST::QualifiedPathInType &path); + + // rust-expr.h + virtual void visit (AST::LiteralExpr &expr); + virtual void visit (AST::AttrInputLiteral &attr_input); + virtual void visit (AST::MetaItemLitExpr &meta_item); + virtual void visit (AST::MetaItemPathLit &meta_item); + virtual void visit (AST::BorrowExpr &expr); + virtual void visit (AST::DereferenceExpr &expr); + virtual void visit (AST::ErrorPropagationExpr &expr); + virtual void visit (AST::NegationExpr &expr); + virtual void visit (AST::ArithmeticOrLogicalExpr &expr); + virtual void visit (AST::ComparisonExpr &expr); + virtual void visit (AST::LazyBooleanExpr &expr); + virtual void visit (AST::TypeCastExpr &expr); + virtual void visit (AST::AssignmentExpr &expr); + virtual void visit (AST::CompoundAssignmentExpr &expr); + virtual void visit (AST::GroupedExpr &expr); + // virtual void visit(ArrayElems& elems); + virtual void visit (AST::ArrayElemsValues &elems); + virtual void visit (AST::ArrayElemsCopied &elems); + virtual void visit (AST::ArrayExpr &expr); + virtual void visit (AST::ArrayIndexExpr &expr); + virtual void visit (AST::TupleExpr &expr); + virtual void visit (AST::TupleIndexExpr &expr); + virtual void visit (AST::StructExprStruct &expr); + // virtual void visit(StructExprField& field); + virtual void visit (AST::StructExprFieldIdentifier &field); + virtual void visit (AST::StructExprFieldIdentifierValue &field); + virtual void visit (AST::StructExprFieldIndexValue &field); + virtual void visit (AST::StructExprStructFields &expr); + virtual void visit (AST::StructExprStructBase &expr); + virtual void visit (AST::StructExprTuple &expr); + virtual void visit (AST::StructExprUnit &expr); + // virtual void visit(EnumExprField& field); + virtual void visit (AST::EnumExprFieldIdentifier &field); + virtual void visit (AST::EnumExprFieldIdentifierValue &field); + virtual void visit (AST::EnumExprFieldIndexValue &field); + virtual void visit (AST::EnumExprStruct &expr); + virtual void visit (AST::EnumExprTuple &expr); + virtual void visit (AST::EnumExprFieldless &expr); + virtual void visit (AST::CallExpr &expr); + virtual void visit (AST::MethodCallExpr &expr); + virtual void visit (AST::FieldAccessExpr &expr); + virtual void visit (AST::ClosureExprInner &expr); + virtual void visit (AST::BlockExpr &expr); + virtual void visit (AST::ClosureExprInnerTyped &expr); + virtual void visit (AST::ContinueExpr &expr); + virtual void visit (AST::BreakExpr &expr); + virtual void visit (AST::RangeFromToExpr &expr); + virtual void visit (AST::RangeFromExpr &expr); + virtual void visit (AST::RangeToExpr &expr); + virtual void visit (AST::RangeFullExpr &expr); + virtual void visit (AST::RangeFromToInclExpr &expr); + virtual void visit (AST::RangeToInclExpr &expr); + virtual void visit (AST::ReturnExpr &expr); + virtual void visit (AST::UnsafeBlockExpr &expr); + virtual void visit (AST::LoopExpr &expr); + virtual void visit (AST::WhileLoopExpr &expr); + virtual void visit (AST::WhileLetLoopExpr &expr); + virtual void visit (AST::ForLoopExpr &expr); + virtual void visit (AST::IfExpr &expr); + virtual void visit (AST::IfExprConseqElse &expr); + virtual void visit (AST::IfExprConseqIf &expr); + virtual void visit (AST::IfExprConseqIfLet &expr); + virtual void visit (AST::IfLetExpr &expr); + virtual void visit (AST::IfLetExprConseqElse &expr); + virtual void visit (AST::IfLetExprConseqIf &expr); + virtual void visit (AST::IfLetExprConseqIfLet &expr); + // virtual void visit(MatchCase& match_case); + virtual void visit (AST::MatchCaseBlockExpr &match_case); + virtual void visit (AST::MatchCaseExpr &match_case); + virtual void visit (AST::MatchExpr &expr); + virtual void visit (AST::AwaitExpr &expr); + virtual void visit (AST::AsyncBlockExpr &expr); + + // rust-item.h + virtual void visit (AST::TypeParam ¶m); + // virtual void visit(WhereClauseItem& item); + virtual void visit (AST::LifetimeWhereClauseItem &item); + virtual void visit (AST::TypeBoundWhereClauseItem &item); + virtual void visit (AST::Method &method); + virtual void visit (AST::ModuleBodied &module); + virtual void visit (AST::ModuleNoBody &module); + virtual void visit (AST::ExternCrate &crate); + // virtual void visit(UseTree& use_tree); + virtual void visit (AST::UseTreeGlob &use_tree); + virtual void visit (AST::UseTreeList &use_tree); + virtual void visit (AST::UseTreeRebind &use_tree); + virtual void visit (AST::UseDeclaration &use_decl); + virtual void visit (AST::Function &function); + virtual void visit (AST::TypeAlias &type_alias); + virtual void visit (AST::StructStruct &struct_item); + virtual void visit (AST::TupleStruct &tuple_struct); + virtual void visit (AST::EnumItem &item); + virtual void visit (AST::EnumItemTuple &item); + virtual void visit (AST::EnumItemStruct &item); + virtual void visit (AST::EnumItemDiscriminant &item); + virtual void visit (AST::Enum &enum_item); + virtual void visit (AST::Union &union_item); + virtual void visit (AST::ConstantItem &const_item); + virtual void visit (AST::StaticItem &static_item); + virtual void visit (AST::TraitItemFunc &item); + virtual void visit (AST::TraitItemMethod &item); + virtual void visit (AST::TraitItemConst &item); + virtual void visit (AST::TraitItemType &item); + virtual void visit (AST::Trait &trait); + virtual void visit (AST::InherentImpl &impl); + virtual void visit (AST::TraitImpl &impl); + // virtual void visit(ExternalItem& item); + virtual void visit (AST::ExternalStaticItem &item); + virtual void visit (AST::ExternalFunctionItem &item); + virtual void visit (AST::ExternBlock &block); + + // rust-macro.h + virtual void visit (AST::MacroMatchFragment &match); + virtual void visit (AST::MacroMatchRepetition &match); + virtual void visit (AST::MacroMatcher &matcher); + virtual void visit (AST::MacroRulesDefinition &rules_def); + virtual void visit (AST::MacroInvocation ¯o_invoc); + virtual void visit (AST::MetaItemPath &meta_item); + virtual void visit (AST::MetaItemSeq &meta_item); + virtual void visit (AST::MetaWord &meta_item); + virtual void visit (AST::MetaNameValueStr &meta_item); + virtual void visit (AST::MetaListPaths &meta_item); + virtual void visit (AST::MetaListNameValueStr &meta_item); + + // rust-pattern.h + virtual void visit (AST::LiteralPattern &pattern); + virtual void visit (AST::IdentifierPattern &pattern); + virtual void visit (AST::WildcardPattern &pattern); + // virtual void visit(RangePatternBound& bound); + virtual void visit (AST::RangePatternBoundLiteral &bound); + virtual void visit (AST::RangePatternBoundPath &bound); + virtual void visit (AST::RangePatternBoundQualPath &bound); + virtual void visit (AST::RangePattern &pattern); + virtual void visit (AST::ReferencePattern &pattern); + // virtual void visit(StructPatternField& field); + virtual void visit (AST::StructPatternFieldTuplePat &field); + virtual void visit (AST::StructPatternFieldIdentPat &field); + virtual void visit (AST::StructPatternFieldIdent &field); + virtual void visit (AST::StructPattern &pattern); + // virtual void visit(TupleStructItems& tuple_items); + virtual void visit (AST::TupleStructItemsNoRange &tuple_items); + virtual void visit (AST::TupleStructItemsRange &tuple_items); + virtual void visit (AST::TupleStructPattern &pattern); + // virtual void visit(TuplePatternItems& tuple_items); + virtual void visit (AST::TuplePatternItemsMultiple &tuple_items); + virtual void visit (AST::TuplePatternItemsRanged &tuple_items); + virtual void visit (AST::TuplePattern &pattern); + virtual void visit (AST::GroupedPattern &pattern); + virtual void visit (AST::SlicePattern &pattern); + + // rust-stmt.h + virtual void visit (AST::EmptyStmt &stmt); + virtual void visit (AST::LetStmt &stmt); + virtual void visit (AST::ExprStmtWithoutBlock &stmt); + virtual void visit (AST::ExprStmtWithBlock &stmt); + + // rust-type.h + virtual void visit (AST::TraitBound &bound); + virtual void visit (AST::ImplTraitType &type); + virtual void visit (AST::TraitObjectType &type); + virtual void visit (AST::ParenthesisedType &type); + virtual void visit (AST::ImplTraitTypeOneBound &type); + virtual void visit (AST::TraitObjectTypeOneBound &type); + virtual void visit (AST::TupleType &type); + virtual void visit (AST::NeverType &type); + virtual void visit (AST::RawPointerType &type); + virtual void visit (AST::ReferenceType &type); + virtual void visit (AST::ArrayType &type); + virtual void visit (AST::SliceType &type); + virtual void visit (AST::InferredType &type); + virtual void visit (AST::BareFunctionType &type); + +private: + TypeResolution (AST::Crate &crate); + + bool go (); + + Scope scope; + AST::Crate &crate; + + std::vector letPatternBuffer; +}; + +} // namespace Analysis +} // namespace Rust diff --git a/gcc/rust/analysis/scope.h b/gcc/rust/analysis/scope.h new file mode 100644 index 0000000..0374251 --- /dev/null +++ b/gcc/rust/analysis/scope.h @@ -0,0 +1,55 @@ +#pragma once + +#include "rust-system.h" +#include "rust-ast-full.h" + +namespace Rust { +namespace Analysis { + +class Scope +{ +public: + Scope () : scopeStack () {} + + ~Scope () {} + + bool Insert (std::string key, AST::Type *val) + { + if (scopeStack.back ().find (key) != scopeStack.back ().end ()) + { + return false; + } + + scopeStack.back ().insert (std::make_pair (key, std::move (val))); + return true; + } + + bool Lookup (std::string key, AST::Type **result) + { + for (auto it = scopeStack.rbegin (); it != scopeStack.rend (); ++it) + { + auto lookup = it->find (key); + if (lookup != it->end ()) + { + *result = lookup->second; + return true; + } + } + return false; + } + + void Push () { scopeStack.push_back ({}); } + + std ::map Pop () + { + auto toplevel = scopeStack.back (); + scopeStack.pop_back (); + return toplevel; + } + +private: + std::vector > scopeStack; +}; + +} // namespace Analysis +} // namespace Rust -- cgit v1.1