Changeset 98e8b3b for src

Timestamp:

Sep 10, 2020, 11:26:58 AM (3 years ago)

Author:

Andrew Beach <ajbeach@…>

Branches:

arm-eh, enum, forall-pointer-decay, jacob/cs343-translation, master, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

ae45007

Parents:

b9fa85b

Message:

ast::ReferenceToType? is now ast::BaseInstType?.

Location:

src

Files:

• AST/Convert.cpp (modified) (2 diffs)
• AST/Fwd.hpp (modified) (1 diff)
• AST/GenericSubstitution.cpp (modified) (1 diff)
• AST/Node.cpp (modified) (1 diff)
• AST/Print.cpp (modified) (1 diff)
• AST/SymbolTable.cpp (modified) (2 diffs)
• AST/Type.cpp (modified) (4 diffs)
• AST/Type.hpp (modified) (9 diffs)
• AST/TypeSubstitution.cpp (modified) (1 diff)
• AST/TypeSubstitution.hpp (modified) (1 diff)
• ResolvExpr/CandidateFinder.cpp (modified) (2 diffs)
• ResolvExpr/CurrentObject.cc (modified) (3 diffs)
• SymTab/Mangler.cc (modified) (2 diffs)
• SymTab/Validate.cc (modified) (1 diff)

src/AST/Convert.cpp

@@ -1162 +1162 @@
         }
 
-        const ast::Type * postvisit( const ast::ReferenceToType * old, ReferenceToType * ty ) {
+        const ast::Type * postvisit( const ast::BaseInstType * old, ReferenceToType * ty ) {
                 ty->forall = get<TypeDecl>().acceptL( old->forall );
                 ty->parameters = get<Expression>().acceptL( old->params );
@@ -2521 +2521 @@
         }
 
-        void postvisit( const ReferenceToType * old, ast::ReferenceToType * ty ) {
+        void postvisit( const ReferenceToType * old, ast::BaseInstType * ty ) {
                 ty->forall = GET_ACCEPT_V( forall, TypeDecl );
                 ty->params = GET_ACCEPT_V( parameters, Expr );

src/AST/Fwd.hpp

@@ -107 +107 @@
 class QualifiedType;
 class FunctionType;
-class ReferenceToType;
+class BaseInstType;
 template<typename decl_t> class SueInstType;
 using StructInstType = SueInstType<StructDecl>;

src/AST/GenericSubstitution.cpp

@@ -42 +42 @@
         private:
                 // make substitution for generic type
-                void makeSub( const ReferenceToType * ty ) {
+                void makeSub( const BaseInstType * ty ) {
                         visit_children = false;
                         const AggregateDecl * aggr = ty->aggr();

src/AST/Node.cpp

@@ -266 +266 @@
 template class ast::ptr_base< ast::FunctionType, ast::Node::ref_type::weak >;
 template class ast::ptr_base< ast::FunctionType, ast::Node::ref_type::strong >;
-template class ast::ptr_base< ast::ReferenceToType, ast::Node::ref_type::weak >;
-template class ast::ptr_base< ast::ReferenceToType, ast::Node::ref_type::strong >;
+template class ast::ptr_base< ast::BaseInstType, ast::Node::ref_type::weak >;
+template class ast::ptr_base< ast::BaseInstType, ast::Node::ref_type::strong >;
 template class ast::ptr_base< ast::StructInstType, ast::Node::ref_type::weak >;
 template class ast::ptr_base< ast::StructInstType, ast::Node::ref_type::strong >;

src/AST/Print.cpp

@@ -270 +270 @@
         }
 
-        void preprint( const ast::ReferenceToType * node ) {
+        void preprint( const ast::BaseInstType * node ) {
                 print( node->forall );
                 print( node->attributes );

src/AST/SymbolTable.cpp

@@ -313 +313 @@
                 if ( ! expr->result ) continue;
                 const Type * resTy = expr->result->stripReferences();
-                auto aggrType = dynamic_cast< const ReferenceToType * >( resTy );
+                auto aggrType = dynamic_cast< const BaseInstType * >( resTy );
                 assertf( aggrType, "WithStmt expr has non-aggregate type: %s",
                         toString( expr->result ).c_str() );
@@ -654 +654 @@
                         if ( dwt->name == "" ) {
                                 const Type * t = dwt->get_type()->stripReferences();
-                                if ( auto rty = dynamic_cast<const ReferenceToType *>( t ) ) {
+                                if ( auto rty = dynamic_cast<const BaseInstType *>( t ) ) {
                                         if ( ! dynamic_cast<const StructInstType *>(rty)
                                                 && ! dynamic_cast<const UnionInstType *>(rty) ) continue;

src/AST/Type.cpp

@@ -124 +124 @@
 }
 
-// --- ReferenceToType
-
-void ReferenceToType::initWithSub( const ReferenceToType & o, Pass< ForallSubstitutor > & sub ) {
+// --- BaseInstType
+
+void BaseInstType::initWithSub( const BaseInstType & o, Pass< ForallSubstitutor > & sub ) {
         ParameterizedType::initWithSub( o, sub ); // initialize substitution
         params = sub.core( o.params );            // apply to parameters
 }
 
-ReferenceToType::ReferenceToType( const ReferenceToType & o )
+BaseInstType::BaseInstType( const BaseInstType & o )
 : ParameterizedType( o.qualifiers, copy( o.attributes ) ), params(), name( o.name ), 
   hoistType( o.hoistType ) {
@@ -138 +138 @@
 }
 
-std::vector<readonly<Decl>> ReferenceToType::lookup( const std::string& name ) const {
+std::vector<readonly<Decl>> BaseInstType::lookup( const std::string& name ) const {
         assertf( aggr(), "Must have aggregate to perform lookup" );
 
@@ -153 +153 @@
 SueInstType<decl_t>::SueInstType(
         const decl_t * b, CV::Qualifiers q, std::vector<ptr<Attribute>>&& as )
-: ReferenceToType( b->name, q, move(as) ), base( b ) {}
+: BaseInstType( b->name, q, move(as) ), base( b ) {}
 
 template<typename decl_t>
@@ -168 +168 @@
 TraitInstType::TraitInstType(
         const TraitDecl * b, CV::Qualifiers q, std::vector<ptr<Attribute>>&& as )
-: ReferenceToType( b->name, q, move(as) ), base( b ) {}
+: BaseInstType( b->name, q, move(as) ), base( b ) {}
 
 // --- TypeInstType
 
 TypeInstType::TypeInstType( const TypeInstType & o )
-: ReferenceToType( o.name, o.qualifiers, copy( o.attributes ) ), base(), kind( o.kind ) {
+: BaseInstType( o.name, o.qualifiers, copy( o.attributes ) ), base(), kind( o.kind ) {
         Pass< ForallSubstitutor > sub;
         initWithSub( o, sub );      // initialize substitution

src/AST/Type.hpp

@@ -329 +329 @@
 
 /// base class for types that refer to types declared elsewhere (aggregates and typedefs)
-class ReferenceToType : public ParameterizedType {
+class BaseInstType : public ParameterizedType {
 protected:
         /// Initializes forall and parameters based on substitutor
-        void initWithSub( const ReferenceToType & o, Pass< ForallSubstitutor > & sub );
+        void initWithSub( const BaseInstType & o, Pass< ForallSubstitutor > & sub );
 public:
         std::vector<ptr<Expr>> params;
@@ -338 +338 @@
         bool hoistType = false;
 
-        ReferenceToType(
+        BaseInstType(
                 const std::string& n, CV::Qualifiers q = {}, std::vector<ptr<Attribute>> && as = {} )
         : ParameterizedType(q, std::move(as)), params(), name(n) {}
 
-        ReferenceToType( const ReferenceToType & o );
+        BaseInstType( const BaseInstType & o );
 
         /// Gets aggregate declaration this type refers to
@@ -350 +350 @@
 
 private:
-        virtual ReferenceToType * clone() const override = 0;
+        virtual BaseInstType * clone() const override = 0;
         MUTATE_FRIEND
 };
@@ -356 +356 @@
 // Common implementation for the SUE instance types. Not to be used directly.
 template<typename decl_t>
-class SueInstType final : public ReferenceToType {
+class SueInstType final : public BaseInstType {
 public:
         using base_type = decl_t;
@@ -363 +363 @@
         SueInstType(
                 const std::string& n, CV::Qualifiers q = {}, std::vector<ptr<Attribute>> && as = {} )
-        : ReferenceToType( n, q, std::move(as) ), base() {}
+        : BaseInstType( n, q, std::move(as) ), base() {}
 
         SueInstType(
@@ -388 +388 @@
 
 /// An instance of a trait type.
-class TraitInstType final : public ReferenceToType {
+class TraitInstType final : public BaseInstType {
 public:
         readonly<TraitDecl> base;
@@ -394 +394 @@
         TraitInstType(
                 const std::string& n, CV::Qualifiers q = {}, std::vector<ptr<Attribute>> && as = {} )
-        : ReferenceToType( n, q, std::move(as) ), base() {}
+        : BaseInstType( n, q, std::move(as) ), base() {}
 
         TraitInstType(
@@ -411 +411 @@
 
 /// instance of named type alias (typedef or variable)
-class TypeInstType final : public ReferenceToType {
+class TypeInstType final : public BaseInstType {
 public:
         readonly<TypeDecl> base;
@@ -419 +419 @@
                 const std::string& n, const TypeDecl * b, CV::Qualifiers q = {},
                 std::vector<ptr<Attribute>> && as = {} )
-        : ReferenceToType( n, q, std::move(as) ), base( b ), kind( b->kind ) {}
+        : BaseInstType( n, q, std::move(as) ), base( b ), kind( b->kind ) {}
         TypeInstType( const std::string& n, TypeDecl::Kind k, CV::Qualifiers q = {},
                 std::vector<ptr<Attribute>> && as = {} )
-        : ReferenceToType( n, q, std::move(as) ), base(), kind( k ) {}
+        : BaseInstType( n, q, std::move(as) ), base(), kind( k ) {}
 
         TypeInstType( const TypeInstType & o );

src/AST/TypeSubstitution.cpp

@@ -176 +176 @@
 }
 
-void TypeSubstitution::Substituter::handleAggregateType( const ReferenceToType * type ) {
+void TypeSubstitution::Substituter::handleAggregateType( const BaseInstType * type ) {
         GuardValue( boundVars );
         // bind type variables from forall-qualifiers

src/AST/TypeSubstitution.hpp

@@ -169 +169 @@
                 void previsit( const ParameterizedType * type );
                 /// Records type variable bindings from forall-statements and instantiations of generic types
-                void handleAggregateType( const ReferenceToType * type );
+                void handleAggregateType( const BaseInstType * type );
 
                 void previsit( const StructInstType * aggregateUseType );

src/ResolvExpr/CandidateFinder.cpp

@@ -816 +816 @@
                 /// Adds aggregate member interpretations
                 void addAggMembers(
-                        const ast::ReferenceToType * aggrInst, const ast::Expr * expr,
+                        const ast::BaseInstType * aggrInst, const ast::Expr * expr,
                         const Candidate & cand, const Cost & addedCost, const std::string & name
                 ) {
@@ -1263 +1263 @@
 
                 void postvisit( const ast::UntypedOffsetofExpr * offsetofExpr ) {
-                        const ast::ReferenceToType * aggInst;
+                        const ast::BaseInstType * aggInst;
                         if (( aggInst = offsetofExpr->type.as< ast::StructInstType >() )) ;
                         else if (( aggInst = offsetofExpr->type.as< ast::UnionInstType >() )) ;

src/ResolvExpr/CurrentObject.cc

@@ -923 +923 @@
 
         MemberIterator * createMemberIterator( const CodeLocation & loc, const Type * type ) {
-                if ( auto aggr = dynamic_cast< const ReferenceToType * >( type ) ) {
+                if ( auto aggr = dynamic_cast< const BaseInstType * >( type ) ) {
                         if ( auto sit = dynamic_cast< const StructInstType * >( aggr ) ) {
                                 return new StructIterator{ loc, sit };
@@ -932 +932 @@
                                         dynamic_cast< const EnumInstType * >( type )
                                                 || dynamic_cast< const TypeInstType * >( type ),
-                                        "Encountered unhandled ReferenceToType in createMemberIterator: %s",
+                                        "Encountered unhandled BaseInstType in createMemberIterator: %s",
                                                 toString( type ).c_str() );
                                 return new SimpleIterator{ loc, type };
@@ -965 +965 @@
                                         DesignatorChain & d = *dit;
                                         PRINT( std::cerr << "____actual: " << t << std::endl; )
-                                        if ( auto refType = dynamic_cast< const ReferenceToType * >( t ) ) {
+                                        if ( auto refType = dynamic_cast< const BaseInstType * >( t ) ) {
                                                 // concatenate identical field names
                                                 for ( const Decl * mem : refType->lookup( nexpr->name ) ) {

src/SymTab/Mangler.cc

@@ -437 +437 @@
                   private:
                         void mangleDecl( const ast::DeclWithType *declaration );
-                        void mangleRef( const ast::ReferenceToType *refType, std::string prefix );
+                        void mangleRef( const ast::BaseInstType *refType, std::string prefix );
 
                         void printQualifiers( const ast::Type *type );
@@ -560 +560 @@
                 }
 
-                void Mangler_new::mangleRef( const ast::ReferenceToType * refType, std::string prefix ) {
+                void Mangler_new::mangleRef( const ast::BaseInstType * refType, std::string prefix ) {
                         printQualifiers( refType );
 

src/SymTab/Validate.cc

@@ -1508 +1508 @@
                 }
 
-                void checkGenericParameters( const ast::ReferenceToType * inst ) {
+                void checkGenericParameters( const ast::BaseInstType * inst ) {
                         for ( const ast::Expr * param : inst->params ) {
                                 if ( ! dynamic_cast< const ast::TypeExpr * >( param ) ) {