Changeset 8f31be6

Timestamp:

Jul 6, 2023, 11:07:27 AM (12 months ago)

Author:

Andrew Beach <ajbeach@…>

Branches:

master

Children:

b4d2b3b

Parents:

c8bf1b5

Message:

Fixed some warnings, deleted some commented out code.

Location:

src

Files:

• AST/SymbolTable.cpp (modified) (2 diffs)
• GenPoly/SpecializeNew.cpp (modified) (2 diffs)
• ResolvExpr/CommonType.cc (modified) (3 diffs)
• ResolvExpr/Unify.cc (modified) (2 diffs)

src/AST/SymbolTable.cpp

@@ -19 +19 @@
 
 #include "Copy.hpp"
-#include <iostream>
-#include <algorithm>
-
 #include "Decl.hpp"
 #include "Expr.hpp"
@@ -206 +203 @@
                         out.push_back(decl.second);
                 }
-
-                // std::cerr << otypeKey << ' ' << out.size() << std::endl;
         }
 

src/GenPoly/SpecializeNew.cpp

@@ -104 +104 @@
 
 bool needsPolySpecialization(
-                const ast::Type * formalType,
+                const ast::Type * /*formalType*/,
                 const ast::Type * actualType,
                 const ast::TypeSubstitution * subs ) {
@@ -126 +126 @@
                         if ( closedVars.find( *inst ) == closedVars.end() ) {
                                 return true;
-                        }
-                        else {
+                        } else {
                                 assertf(false, "closed: %s", inst->name.c_str());
                         }

src/ResolvExpr/CommonType.cc

@@ -696 +696 @@
                 void postvisit( const ast::BasicType * basic ) {
                         if ( auto basic2 = dynamic_cast< const ast::BasicType * >( type2 ) ) {
-                                #warning remove casts when `commonTypes` moved to new AST
-                                
-                                /*
-                                ast::BasicType::Kind kind = (ast::BasicType::Kind)(int)commonTypes[ (BasicType::Kind)(int)basic->kind ][ (BasicType::Kind)(int)basic2->kind ];
-                                if (
-                                        ( ( kind == basic->kind && basic->qualifiers >= basic2->qualifiers )
-                                                || widen.first )
-                                        && ( ( kind == basic2->kind && basic->qualifiers <= basic2->qualifiers )
-                                                || widen.second )
-                                ) {
-                                        result = new ast::BasicType{ kind, basic->qualifiers | basic2->qualifiers };
-                                }
-                                */
                                 ast::BasicType::Kind kind;
                                 if (basic->kind != basic2->kind && !widen.first && !widen.second) return;
@@ -719 +706 @@
                                         result = new ast::BasicType{ kind, basic->qualifiers | basic2->qualifiers };
                                 }
-                                
                         } else if (
                                 dynamic_cast< const ast::ZeroType * >( type2 )
                                 || dynamic_cast< const ast::OneType * >( type2 )
                         ) {
-                                #warning remove casts when `commonTypes` moved to new AST
-                                ast::BasicType::Kind kind = (ast::BasicType::Kind)(int)commonTypes[ (BasicType::Kind)(int)basic->kind ][ (BasicType::Kind)(int)ast::BasicType::SignedInt ];
-                                /*
-                                if ( // xxx - what does qualifier even do here??
-                                        ( ( basic->qualifiers >= type2->qualifiers )
-                                                || widen.first )
-                                         && ( ( /* kind != basic->kind && basic->qualifiers <= type2->qualifiers )
-                                                || widen.second )
-                                ) 
-                                */
                                 if (widen.second) {
                                         result = new ast::BasicType{ basic->kind, basic->qualifiers | type2->qualifiers };
                                 }
                         } else if ( const ast::EnumInstType * enumInst = dynamic_cast< const ast::EnumInstType * >( type2 ) ) {
-                                #warning remove casts when `commonTypes` moved to new AST
                                 const ast::EnumDecl* enumDecl = enumInst->base;
                                 if ( enumDecl->base ) {
                                         result = enumDecl->base.get();
                                 } else {
+                                        #warning remove casts when `commonTypes` moved to new AST
                                         ast::BasicType::Kind kind = (ast::BasicType::Kind)(int)commonTypes[ (BasicType::Kind)(int)basic->kind ][ (BasicType::Kind)(int)ast::BasicType::SignedInt ];
                                         if (
@@ -763 +739 @@
                                 auto entry = open.find( *var );
                                 if ( entry != open.end() ) {
-                                // if (tenv.lookup(*var)) {
                                         ast::AssertionSet need, have;
                                         if ( ! tenv.bindVar(

src/ResolvExpr/Unify.cc

@@ -1298 +1298 @@
                 auto var1 = dynamic_cast< const ast::TypeInstType * >( type1 );
                 auto var2 = dynamic_cast< const ast::TypeInstType * >( type2 );
-                ast::OpenVarSet::const_iterator
-                        entry1 = var1 ? open.find( *var1 ) : open.end(),
-                        entry2 = var2 ? open.find( *var2 ) : open.end();
-                // bool isopen1 = entry1 != open.end();
-                // bool isopen2 = entry2 != open.end();
                 bool isopen1 = var1 && env.lookup(*var1);
                 bool isopen2 = var2 && env.lookup(*var2);
 
-                /*
-                if ( isopen1 && isopen2 ) {
-                        if ( entry1->second.kind != entry2->second.kind ) return false;
-                        return env.bindVarToVar(
-                                var1, var2, ast::TypeData{ entry1->second, entry2->second }, need, have,
-                                open, widen );
-                } else if ( isopen1 ) {
-                        return env.bindVar( var1, type2, entry1->second, need, have, open, widen );
-                } else if ( isopen2 ) {
-                        return env.bindVar( var2, type1, entry2->second, need, have, open, widen, symtab );
-                } */
                 if ( isopen1 && isopen2 ) {
                         if ( var1->base->kind != var2->base->kind ) return false;
@@ -1326 +1310 @@
                 } else if ( isopen2 ) {
                         return env.bindVar( var2, type1, ast::TypeData{var2->base}, need, have, open, widen );
-                }else {
+                } else {
                         return ast::Pass<Unify_new>::read(
                                 type1, type2, env, need, have, open, widen );
                 }
-                
         }