Changeset 2e02851 for src

Timestamp:

Jul 13, 2018, 2:33:18 PM (6 years ago)

Author:

Rob Schluntz <rschlunt@…>

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, no_list, persistent-indexer, pthread-emulation, qualifiedEnum

Children:

ad64520, b1672e1

Parents:

610194e

Message:

Add temporary warning for deprecated anonymous member declarations

Location:

src

Files:

• Common/SemanticError.h (modified) (2 diffs)
• Parser/DeclarationNode.cc (modified) (1 diff)

src/Common/SemanticError.h

@@ -56 +56 @@
         {"reference-conversion"   , "rvalue to reference conversion of rvalue: %s" , Severity::Warn},
         {"qualifiers-zero_t-one_t", "questionable use of type qualifier %s with %s", Severity::Warn},
+        {"aggregate-forward-decl" , "forward declaration of nested aggregate: %s"  , Severity::Warn},
 };
 
@@ -62 +63 @@
         RvalueToReferenceConversion,
         BadQualifiersZeroOne,
+        AggrForwardDecl,
         NUMBER_OF_WARNINGS, //This MUST be the last warning
 };

src/Parser/DeclarationNode.cc

@@ -1003 +1003 @@
                                 // };
                                 if ( ! (extracted && decl->name == "" && ! anon) ) {
+                                        if (decl->name == "") {
+                                                if ( DeclarationWithType * dwt = dynamic_cast<DeclarationWithType *>( decl ) ) {
+                                                        if ( ReferenceToType * aggr = dynamic_cast<ReferenceToType *>( dwt->get_type() ) ) {
+                                                                if ( aggr->name.find("anonymous") == std::string::npos ) {
+                                                                        bool isInline = false;
+                                                                        if (cur->type->kind == TypeData::Aggregate || cur->type->kind == TypeData::AggregateInst) {
+                                                                                if (cur->type->kind == TypeData::Aggregate) {
+                                                                                        isInline = cur->type->aggregate.inLine;
+                                                                                } else {
+                                                                                        isInline = cur->type->aggInst.inLine;
+                                                                                        if ( TypeData * aggr = cur->type->aggInst.aggregate ) {
+                                                                                                if ( aggr->kind == TypeData::Aggregate ) {
+                                                                                                        isInline = isInline || aggr->aggregate.inLine;
+                                                                                                }
+                                                                                        }
+                                                                                }
+                                                                        }
+                                                                        if (! isInline) {
+                                                                                // temporary: warn about anonymous member declarations of named types, since this conflicts with the syntax for the forward declaration of an anonymous type
+                                                                                SemanticWarning( cur->location, Warning::AggrForwardDecl, aggr->name.c_str() );
+                                                                        }
+                                                                }
+                                                        }
+                                                }
+                                        }
                                         decl->location = cur->location;
                                         * out++ = decl;