Changeset 77bfc80

Timestamp:

May 17, 2019, 12:08:46 PM (6 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

ADT, arm-eh, ast-experimental, cleanup-dtors, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

10a1225

Parents:

8ff178d

Message:

Fixed some warnings and better messaging for unimplemented stubs

Location:

src

Files:

• Common/SemanticError.h (modified) (1 diff)
• InitTweak/InitTweak.cc (modified) (4 diffs)
• SynTree/Declaration.cc (modified) (1 diff)
• Tuples/TupleExpansion.cc (modified) (1 diff)
• Tuples/Tuples.h (modified) (2 diffs)

src/Common/SemanticError.h

@@ -17 +17 @@
 
 #include "ErrorObjects.h"
+#include "AST/Node.hpp"
 #include <cstring>
 

src/InitTweak/InitTweak.cc

@@ -437 +437 @@
                 // const ast::Expr * callArg( const CallExpr * call, unsigned int pos ) {
                 //      if( pos >= call->args.size() ) {
-                //              assertf( false, "getCallArg for argument that doesn't exist: (%u); %s.", 
+                //              assertf( false, "getCallArg for argument that doesn't exist: (%u); %s.",
                 //                      pos, toString( call ).c_str() );
                 //      }
@@ -467 +467 @@
         }
         const ast::Expr * getCallArg( const ast::Expr * call, unsigned pos ) {
-                assert(!"implemented; needs to build AST/Expr.cpp");
+                (void)call;
+                (void)pos;
+                #warning unimplemented; needs to build AST/Expr.cpp
+                assertf(false, "unimplemented; needs to build AST/Expr.cpp");
                 // if ( auto app = dynamic_cast< const ast::ApplicationExpr * >( call ) ) {
                 //      return callArg( app, pos );
@@ -482 +485 @@
                 //      return getCallArg( ctor->callExpr, pos );
                 // } else {
-                //      assertf( false, "Unexpected expression type passed to getCallArg: %s", 
+                //      assertf( false, "Unexpected expression type passed to getCallArg: %s",
                 //              toString( call ).c_str() );
                 // }
@@ -548 +551 @@
         }
         const ast::Type* getPointerBase( const ast::Type* t ) {
-                assert(!"needs to build Type.cpp before inclusion");
+                (void)t;
+                #warning needs to build Type.cpp before inclusion
+                assertf(false, "needs to build Type.cpp before inclusion");
                 // if ( const auto * p = dynamic_cast< const ast::PointerType * >( t ) ) {
                 //      return p->base;

src/SynTree/Declaration.cc

@@ -31 +31 @@
 
 Declaration::Declaration( const std::string &name, Type::StorageClasses scs, LinkageSpec::Spec linkage )
-                : name( name ), linkage( linkage ), storageClasses( scs ), uniqueId( 0 ) {
+                : name( name ), linkage( linkage ), uniqueId( 0 ), storageClasses( scs ) {
 }
 
 Declaration::Declaration( const Declaration &other )
-        : BaseSyntaxNode( other ), name( other.name ), linkage( other.linkage ), extension( other.extension ), storageClasses( other.storageClasses ), uniqueId( other.uniqueId ) {
+        : BaseSyntaxNode( other ), name( other.name ), linkage( other.linkage ), extension( other.extension ), uniqueId( other.uniqueId ), storageClasses( other.storageClasses ) {
 }
 

src/Tuples/TupleExpansion.cc

@@ -320 +320 @@
         }
         const ast::Type * makeTupleType( const std::vector<ast::ptr<ast::Expr>> & exprs ) {
-                assert(!"implemented; needs Type.cpp in build");
+                (void) exprs;
+                #warning Not implemented; needs Type.cpp in build
+                assertf(false, "Not implemented; needs Type.cpp in build");
                 // // produce the TupleType which aggregates the types of the exprs
                 // std::vector<ast::ptr<ast::Type>> types;
-                // ast::CV::Qualifiers quals{ 
-                //      ast::CV::Const | ast::CV::Volatile | ast::CV::Restrict | ast::CV::Lvalue | 
+                // ast::CV::Qualifiers quals{
+                //      ast::CV::Const | ast::CV::Volatile | ast::CV::Restrict | ast::CV::Lvalue |
                 //      ast::CV::Atomic | ast::CV::Mutex };
-                
+
                 // for ( const ast::Expr * expr : exprs ) {
                 //      assert( expr->result );

src/Tuples/Tuples.h

@@ -29 +29 @@
 namespace Tuples {
         // TupleAssignment.cc
-        void handleTupleAssignment( ResolvExpr::AlternativeFinder & currentFinder, UntypedExpr * assign, 
+        void handleTupleAssignment( ResolvExpr::AlternativeFinder & currentFinder, UntypedExpr * assign,
                 std::vector< ResolvExpr::AlternativeFinder >& args );
-        
+
         // TupleExpansion.cc
         /// expands z.[a, b.[x, y], c] into [z.a, z.b.x, z.b.y, z.c], inserting UniqueExprs as appropriate
@@ -48 +48 @@
         /// returns a TypeInstType if `type` is a ttype, nullptr otherwise
         TypeInstType * isTtype( Type * type );
+        const ast::TypeInstType * isTtype( const ast::Type * type );
 
         /// returns true if the expression may contain side-effects.