Changeset ae32d96 for src/SymTab

Timestamp:

May 30, 2018, 5:57:43 PM (7 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, with_gc

Children:

597c34a3, 6810fcb, 94b1022a, cf5e5b1

Parents:

6b4cdd3 (diff), d15a45d (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

Location:

src/SymTab

Files:

• Indexer.cc (modified) (3 diffs)
• Mangler.cc (modified) (3 diffs)

src/SymTab/Indexer.cc

@@ -148 +148 @@
                 for ( auto decl : copy ) {
                         if ( FunctionDecl * function = dynamic_cast< FunctionDecl * >( decl.id ) ) {
-                                std::list< DeclarationWithType * > & params = function->get_functionType()->get_parameters();
+                                std::list< DeclarationWithType * > & params = function->type->parameters;
                                 assert( ! params.empty() );
                                 // use base type of pointer, so that qualifiers on the pointer type aren't considered.
@@ -170 +170 @@
                                 bool noUserDefinedFunc = ! val.existsUserDefinedFunc;
                                 bool isUserDefinedFunc = ball.isUserDefinedFunc;
-                                bool isAcceptableDefaultCtor = (! val.existsUserDefinedCtor || (! val.existsUserDefinedDefaultCtor && ball.decl.id->get_linkage() == LinkageSpec::Intrinsic)) && ball.isDefaultCtor; // allow default constructors only when no user-defined constructors exist, except in the case of intrinsics, which require exact overrides
+                                bool isAcceptableDefaultCtor = (! val.existsUserDefinedCtor || (! val.existsUserDefinedDefaultCtor && ball.decl.id->linkage == LinkageSpec::Intrinsic)) && ball.isDefaultCtor; // allow default constructors only when no user-defined constructors exist, except in the case of intrinsics, which require exact overrides
                                 bool isAcceptableCopyFunc = ! val.existsUserDefinedCopyFunc && ball.isCopyFunc; // handles copy ctor and assignment operator
                                 bool isAcceptableDtor = ! val.existsUserDefinedDtor && ball.isDtor;
@@ -471 +471 @@
         void Indexer::addId( DeclarationWithType * decl, Expression * baseExpr ) {
                 // default handling of conflicts is to raise an error
-                addId( decl, [decl](IdData &, const std::string & msg) { SemanticError( decl, msg ); return true; }, baseExpr );
+                addId( decl, [decl](IdData &, const std::string & msg) { SemanticError( decl, msg ); return true; }, baseExpr, decl->isDeleted ? decl : nullptr );
         }
 

src/SymTab/Mangler.cc

@@ -171 +171 @@
                                         "w",    // SignedInt128
                                         "Uw",   // UnsignedInt128
-                                        "a",   // Float80
-                                        "A",   // Float128
+                                        "x",   // Float80
+                                        "y",   // Float128
                                 };
                                 static_assert(
@@ -225 +225 @@
                                 GuardValue( inFunctionType );
                                 inFunctionType = true;
-                                std::list< Type* > returnTypes = getTypes( functionType->get_returnVals() );
+                                std::list< Type* > returnTypes = getTypes( functionType->returnVals );
                                 acceptAll( returnTypes, *visitor );
                                 mangleName << "_";
-                                std::list< Type* > paramTypes = getTypes( functionType->get_parameters() );
+                                std::list< Type* > paramTypes = getTypes( functionType->parameters );
                                 acceptAll( paramTypes, *visitor );
                                 mangleName << "_";
@@ -236 +236 @@
                                 printQualifiers( refType );
 
-                                mangleName << ( refType->get_name().length() + prefix.length() ) << prefix << refType->get_name();
+                                mangleName << ( refType->name.length() + prefix.length() ) << prefix << refType->name;
 
                                 if ( mangleGenericParams ) {
-                                        std::list< Expression* >& params = refType->get_parameters();
+                                        std::list< Expression* >& params = refType->parameters;
                                         if ( ! params.empty() ) {
                                                 mangleName << "_";
                                                 for ( std::list< Expression* >::const_iterator param = params.begin(); param != params.end(); ++param ) {
                                                         TypeExpr *paramType = dynamic_cast< TypeExpr* >( *param );
-                                                        assertf(paramType, "Aggregate parameters should be type expressions: %s", toString(*param).c_str());
-                                                        maybeAccept( paramType->get_type(), *visitor );
+                                                        assertf(paramType, "Aggregate parameters should be type expressions: %s", toCString(*param));
+                                                        maybeAccept( paramType->type, *visitor );
                                                 }
                                                 mangleName << "_";