Changes in / [b3ed43a3:04994aa]

Files:

• benchmark/plot.py (deleted)
• libcfa/src/bits/collection.hfa (deleted)
• libcfa/src/bits/queue.hfa (deleted)
• libcfa/src/bits/queue_example.cfa (deleted)
• libcfa/src/bits/sequence.hfa (deleted)
• libcfa/src/bits/sequence_example.cfa (deleted)
• libcfa/src/bits/stack.hfa (deleted)
• libcfa/src/bits/stack_example.cfa (deleted)
• libcfa/src/concurrency/kernel.cfa (modified) (1 diff)
• src/AST/Expr.hpp (modified) (1 diff)
• src/AST/SymbolTable.cpp (modified) (9 diffs)
• src/AST/SymbolTable.hpp (modified) (4 diffs)
• src/AST/Type.cpp (modified) (1 diff)
• src/AST/Type.hpp (modified) (1 diff)
• src/InitTweak/FixInit.h (modified) (1 diff)
• src/Parser/ParseNode.h (modified) (1 diff)
• src/ResolvExpr/CandidateFinder.cpp (modified) (7 diffs)
• src/ResolvExpr/CandidateFinder.hpp (modified) (1 diff)
• src/ResolvExpr/Resolver.h (modified) (2 diffs)
• src/ResolvExpr/SatisfyAssertions.cpp (modified) (1 diff)
• tests/.expect/KRfunctions.nast.x64.txt (deleted)
• tests/.expect/KRfunctions.oast.x64.txt (deleted)
• tests/.expect/KRfunctions.x64.txt (added)
• tests/.expect/alloc-ERROR.nast.txt (deleted)
• tests/.expect/alloc-ERROR.oast.txt (deleted)
• tests/.expect/alloc-ERROR.txt (added)
• tests/.expect/attributes.nast.x64.txt (deleted)
• tests/.expect/attributes.oast.x64.txt (deleted)
• tests/.expect/attributes.x64.txt (added)
• tests/.expect/functions.nast.x64.txt (deleted)
• tests/.expect/functions.oast.x64.txt (deleted)
• tests/.expect/functions.x64.txt (added)
• tests/.expect/init1-ERROR.nast.txt (deleted)
• tests/.expect/init1-ERROR.oast.txt (deleted)
• tests/.expect/init1-ERROR.txt (added)
• tests/errors/.expect/completeType.nast.x64.txt (deleted)
• tests/errors/.expect/completeType.oast.x64.txt (deleted)
• tests/errors/.expect/completeType.x64.txt (added)
• tests/raii/.expect/ctor-autogen-ERR1.nast.txt (deleted)
• tests/raii/.expect/ctor-autogen-ERR1.oast.txt (deleted)
• tests/raii/.expect/ctor-autogen-ERR1.txt (added)
• tests/raii/.expect/memberCtors-ERR1.nast.txt (deleted)
• tests/raii/.expect/memberCtors-ERR1.oast.txt (deleted)
• tests/raii/.expect/memberCtors-ERR1.txt (added)
• tests/warnings/.expect/self-assignment.nast.txt (deleted)
• tests/warnings/.expect/self-assignment.oast.txt (deleted)
• tests/warnings/.expect/self-assignment.txt (added)

libcfa/src/concurrency/kernel.cfa

@@ -379 +379 @@
 
         ready_schedule_lock();
-                // Dereference the thread now because once we push it, there is not guaranteed it's still valid.
-                struct cluster * cl = thrd->curr_cluster;
-
-                // push the thread to the cluster ready-queue
-                push( cl, thrd );
-
-                // variable thrd is no longer safe to use
-
-                // wake the cluster using the save variable.
-                __wake_one( cl );
+                push( thrd->curr_cluster, thrd );
+                __wake_one(thrd->curr_cluster);
         ready_schedule_unlock();
 

src/AST/Expr.hpp

@@ -299 +299 @@
 };
 
-/// Inidicates whether the cast is introduced by the CFA type system.
-/// GeneratedCast for casts that the resolver introduces to force a return type
-/// ExplicitCast for casts from user code
-/// ExplicitCast for casts from desugaring advanced CFA features into simpler CFA
-/// example
-///   int * p;     // declaration
-///   (float *) p; // use, with subject cast
-/// subject cast being GeneratedCast means we are considering an interpretation with a type mismatch
-/// subject cast being ExplicitCast means someone in charge wants it that way
+/// Whether a cast existed in the program source or not
 enum GeneratedFlag { ExplicitCast, GeneratedCast };
 

src/AST/SymbolTable.cpp

@@ -95 +95 @@
 }
 
-SymbolTable::SpecialFunctionKind SymbolTable::getSpecialFunctionKind(const std::string & name) {
-        if (name == "?{}") return CTOR;
-        if (name == "^?{}") return DTOR;
-        if (name == "?=?") return ASSIGN;
-        return NUMBER_OF_KINDS;
-}
-
 std::vector<SymbolTable::IdData> SymbolTable::lookupId( const std::string &id ) const {
-        static Stats::Counters::CounterGroup * name_lookup_stats = Stats::Counters::build<Stats::Counters::CounterGroup>("Name Lookup Stats");
-        static std::map<std::string, Stats::Counters::SimpleCounter *> lookups_by_name;
-        static std::map<std::string, Stats::Counters::SimpleCounter *> candidates_by_name;
-
-        SpecialFunctionKind kind = getSpecialFunctionKind(id);
-        if (kind != NUMBER_OF_KINDS) return specialLookupId(kind);
-
         ++*stats().lookup_calls;
         if ( ! idTable ) return {};
@@ -121 +107 @@
                 out.push_back( decl.second );
         }
-
-        if (Stats::Counters::enabled) {
-                if (! lookups_by_name.count(id)) {
-                        // leaks some strings, but it is because Counters do not hold them
-                        auto lookupCounterName = new std::string(id + "%count");
-                        auto candidatesCounterName = new std::string(id + "%candidate");
-                        lookups_by_name.emplace(id, new Stats::Counters::SimpleCounter(lookupCounterName->c_str(), name_lookup_stats));
-                        candidates_by_name.emplace(id, new Stats::Counters::SimpleCounter(candidatesCounterName->c_str(), name_lookup_stats));
-                }
-                (*lookups_by_name[id]) ++;
-                *candidates_by_name[id] += out.size();
-        }
-
-        return out;
-}
-
-std::vector<SymbolTable::IdData> SymbolTable::specialLookupId( SymbolTable::SpecialFunctionKind kind, const std::string & otypeKey ) const {
-        static Stats::Counters::CounterGroup * special_stats = Stats::Counters::build<Stats::Counters::CounterGroup>("Special Lookups");
-        static Stats::Counters::SimpleCounter * stat_counts[3] = {
-                Stats::Counters::build<Stats::Counters::SimpleCounter>("constructor - count", special_stats),
-                Stats::Counters::build<Stats::Counters::SimpleCounter>("destructor - count", special_stats),
-                Stats::Counters::build<Stats::Counters::SimpleCounter>("assignment - count", special_stats)
-        };
-
-        static Stats::Counters::SimpleCounter * stat_candidates[3] = {
-                Stats::Counters::build<Stats::Counters::SimpleCounter>("constructor - candidates", special_stats),
-                Stats::Counters::build<Stats::Counters::SimpleCounter>("destructor - candidates", special_stats),
-                Stats::Counters::build<Stats::Counters::SimpleCounter>("assignment - candidates", special_stats)
-        };
-
-        static Stats::Counters::SimpleCounter * num_lookup_with_key 
-                = Stats::Counters::build<Stats::Counters::SimpleCounter>("keyed lookups", special_stats);
-        static Stats::Counters::SimpleCounter * num_lookup_without_key 
-                = Stats::Counters::build<Stats::Counters::SimpleCounter>("unkeyed lookups", special_stats);
-
-        assert (kind != NUMBER_OF_KINDS);
-        ++*stats().lookup_calls;
-        if ( ! specialFunctionTable[kind] ) return {};
-
-        std::vector<IdData> out;
-
-        if (otypeKey.empty()) { // returns everything
-                ++*num_lookup_without_key;
-                for (auto & table : *specialFunctionTable[kind]) {
-                        for (auto & decl : *table.second) {
-                                out.push_back(decl.second);
-                        }
-                }
-        }
-        else {
-                ++*num_lookup_with_key;
-                ++*stats().map_lookups;
-                auto decls = specialFunctionTable[kind]->find(otypeKey);
-                if (decls == specialFunctionTable[kind]->end()) return {};
-
-                for (auto decl : *(decls->second)) {
-                        out.push_back(decl.second);
-                }
-        }
-
-        ++*stat_counts[kind];
-        *stat_candidates[kind] += out.size();
-
         return out;
 }
@@ -443 +366 @@
 namespace {
         /// gets the base type of the first parameter; decl must be a ctor/dtor/assignment function
-        std::string getOtypeKey( const FunctionType * ftype, bool stripParams = true ) {
-                const auto & params = ftype->params;
+        std::string getOtypeKey( const FunctionDecl * function ) {
+                const auto & params = function->type->params;
                 assert( ! params.empty() );
                 // use base type of pointer, so that qualifiers on the pointer type aren't considered.
                 const Type * base = InitTweak::getPointerBase( params.front() );
                 assert( base );
-                if (stripParams) {
-                        if (dynamic_cast<const PointerType *>(base)) return Mangle::Encoding::pointer;
-                        return Mangle::mangle( base, Mangle::Type | Mangle::NoGenericParams );
-                }
-                else
-                        return Mangle::mangle( base );  
+                return Mangle::mangle( base );
         }
 
@@ -462 +380 @@
                         const DeclWithType * decl, const std::string & otypeKey ) {
                 auto func = dynamic_cast< const FunctionDecl * >( decl );
-                if ( ! func || otypeKey != getOtypeKey( func->type, false ) ) return nullptr;
+                if ( ! func || otypeKey != getOtypeKey( func ) ) return nullptr;
                 return func;
         }
@@ -487 +405 @@
         bool dataIsUserDefinedFunc = ! function->linkage.is_overrideable;
         bool dataIsCopyFunc = InitTweak::isCopyFunction( function );
-        std::string dataOtypeKey = getOtypeKey( function->type, false ); // requires exact match to override autogen
+        std::string dataOtypeKey = getOtypeKey( function );
 
         if ( dataIsUserDefinedFunc && dataIsCopyFunc ) {
@@ -659 +577 @@
                 const DeclWithType * decl, SymbolTable::OnConflict handleConflicts, const Expr * baseExpr,
                 const Decl * deleter ) {
-        SpecialFunctionKind kind = getSpecialFunctionKind(decl->name);
-        if (kind == NUMBER_OF_KINDS) { // not a special decl
-                addId(decl, decl->name, idTable, handleConflicts, baseExpr, deleter);
-        }
-        else {
-                std::string key;
-                if (auto func = dynamic_cast<const FunctionDecl *>(decl)) {
-                        key = getOtypeKey(func->type);
-                }
-                else if (auto obj = dynamic_cast<const ObjectDecl *>(decl)) {
-                        key = getOtypeKey(obj->type.strict_as<PointerType>()->base.strict_as<FunctionType>());
-                }
-                else {
-                        assertf(false, "special decl with non-function type");
-                }
-                addId(decl, key, specialFunctionTable[kind], handleConflicts, baseExpr, deleter);
-        }
-}
-
-void SymbolTable::addId(
-                const DeclWithType * decl, const std::string & lookupKey, IdTable::Ptr & table, SymbolTable::OnConflict handleConflicts, const Expr * baseExpr,
-                const Decl * deleter ) {
         ++*stats().add_calls;
         const std::string &name = decl->name;
@@ -711 +607 @@
         // ensure tables exist and add identifier
         MangleTable::Ptr mangleTable;
-        if ( ! table ) {
-                table = IdTable::new_ptr();
+        if ( ! idTable ) {
+                idTable = IdTable::new_ptr();
                 mangleTable = MangleTable::new_ptr();
         } else {
                 ++*stats().map_lookups;
-                auto decls = table->find( lookupKey );
-                if ( decls == table->end() ) {
+                auto decls = idTable->find( name );
+                if ( decls == idTable->end() ) {
                         mangleTable = MangleTable::new_ptr();
                 } else {
@@ -732 +628 @@
                                                 lazyInitScope();
                                                 *stats().map_mutations += 2;
-                                                table = table->set(
-                                                        lookupKey,
+                                                idTable = idTable->set(
+                                                        name,
                                                         mangleTable->set(
                                                                 mangleName,
@@ -748 +644 @@
         IdData data{ decl, baseExpr, deleter, scope };
         // Ensure that auto-generated ctor/dtor/assignment are deleted if necessary
-        if (table != idTable) { // adding to special table
-                if ( ! removeSpecialOverrides( data, mangleTable ) ) return;
-        }
+        if ( ! removeSpecialOverrides( data, mangleTable ) ) return;
         *stats().map_mutations += 2;
-        table = table->set( lookupKey, mangleTable->set( mangleName, std::move(data) ) );
+        idTable = idTable->set( name, mangleTable->set( mangleName, std::move(data) ) );
 }
 

src/AST/SymbolTable.hpp

@@ -33 +33 @@
 class SymbolTable final : public std::enable_shared_from_this<ast::SymbolTable> {
 public:
-        /// special functions stored in dedicated tables, with different lookup keys
-        enum SpecialFunctionKind {CTOR, DTOR, ASSIGN, NUMBER_OF_KINDS};
-        static SpecialFunctionKind getSpecialFunctionKind(const std::string & name);
-
         /// Stored information about a declaration
         struct IdData {
@@ -81 +77 @@
         UnionTable::Ptr unionTable;    ///< union namespace
         TraitTable::Ptr traitTable;    ///< trait namespace
-        IdTable::Ptr specialFunctionTable[NUMBER_OF_KINDS];
-
-        // using SpecialFuncTable = PersistentMap< std::string, IdTable::Ptr >; // fname (ctor/dtor/assign) - otypekey
-        // SpecialFuncTable::Ptr specialFuncTable;
 
         using Ptr = std::shared_ptr<const SymbolTable>;
@@ -103 +95 @@
         /// Gets all declarations with the given ID
         std::vector<IdData> lookupId( const std::string &id ) const;
-        /// Gets special functions associated with a type; if no key is given, returns everything
-        std::vector<IdData> specialLookupId( SpecialFunctionKind kind, const std::string & otypeKey = "" ) const;
         /// Gets the top-most type declaration with the given ID
         const NamedTypeDecl * lookupType( const std::string &id ) const;
@@ -196 +186 @@
                 const Decl * deleter = nullptr );
 
-        /// common code for addId when special decls are placed into separate tables
-        void addId(
-                const DeclWithType * decl, const std::string & lookupKey, IdTable::Ptr & idTable, OnConflict handleConflicts, 
-                const Expr * baseExpr = nullptr, const Decl * deleter = nullptr);
-        
         /// adds all of the members of the Aggregate (addWith helper)
         void addMembers( const AggregateDecl * aggr, const Expr * expr, OnConflict handleConflicts );

src/AST/Type.cpp

@@ -216 +216 @@
 }
 
-bool isUnboundType(const Type * type) {
-        if (auto typeInst = dynamic_cast<const TypeInstType *>(type)) {
-                // xxx - look for a type name produced by renameTyVars.
-
-                // TODO: once TypeInstType representation is updated, it should properly check
-                // if the context id is filled. this is a temporary hack for now
-                if (std::count(typeInst->name.begin(), typeInst->name.end(), '_') >= 3) {
-                        return true;
-                }
-        }
-        return false;
-}
-
 }
 

src/AST/Type.hpp

@@ -535 +535 @@
 };
 
-bool isUnboundType(const Type * type);
-
 }
 

src/InitTweak/FixInit.h

@@ -21 +21 @@
 class Declaration;
 namespace ast {
-        struct TranslationUnit;
+        class TranslationUnit;
 }
 

src/Parser/ParseNode.h

@@ -37 +37 @@
 class Attribute;
 class Declaration;
-struct DeclarationNode;
+class DeclarationNode;
 class DeclarationWithType;
 class ExpressionNode;
 class Initializer;
-struct StatementNode;
+class StatementNode;
 
 //##############################################################################

src/ResolvExpr/CandidateFinder.cpp

@@ -43 +43 @@
 #include "SymTab/Validate.h"      // for validateType
 #include "Tuples/Tuples.h"        // for handleTupleAssignment
-#include "InitTweak/InitTweak.h"  // for getPointerBase
-
-#include "Common/Stats/Counter.h"
 
 #define PRINT( text ) if ( resolvep ) { text }
@@ -867 +864 @@
 
                 void postvisit( const ast::UntypedExpr * untypedExpr ) {
+                        CandidateFinder funcFinder{ symtab, tenv };
+                        funcFinder.find( untypedExpr->func, ResolvMode::withAdjustment() );
+                        // short-circuit if no candidates
+                        if ( funcFinder.candidates.empty() ) return;
+
+                        reason.code = NoMatch;
+
                         std::vector< CandidateFinder > argCandidates =
                                 selfFinder.findSubExprs( untypedExpr->args );
@@ -873 +877 @@
                         // if not tuple assignment, handled as normal function call
                         Tuples::handleTupleAssignment( selfFinder, untypedExpr, argCandidates );
-
-                        CandidateFinder funcFinder{ symtab, tenv };
-                        if (auto nameExpr = untypedExpr->func.as<ast::NameExpr>()) {
-                                auto kind = ast::SymbolTable::getSpecialFunctionKind(nameExpr->name);
-                                if (kind != ast::SymbolTable::SpecialFunctionKind::NUMBER_OF_KINDS) {
-                                        assertf(!argCandidates.empty(), "special function call without argument");
-                                        for (auto & firstArgCand: argCandidates[0]) {
-                                                ast::ptr<ast::Type> argType = firstArgCand->expr->result;
-                                                firstArgCand->env.apply(argType);
-                                                // strip references
-                                                // xxx - is this correct?
-                                                while (argType.as<ast::ReferenceType>()) argType = argType.as<ast::ReferenceType>()->base;
-
-                                                // convert 1-tuple to plain type
-                                                if (auto tuple = argType.as<ast::TupleType>()) {
-                                                        if (tuple->size() == 1) {
-                                                                argType = tuple->types[0];
-                                                        }
-                                                }
-                                                
-                                                // if argType is an unbound type parameter, all special functions need to be searched.
-                                                if (isUnboundType(argType)) {
-                                                        funcFinder.otypeKeys.clear();
-                                                        break;
-                                                }
-
-                                                if (argType.as<ast::PointerType>()) funcFinder.otypeKeys.insert(Mangle::Encoding::pointer);
-                                                else funcFinder.otypeKeys.insert(Mangle::mangle(argType, Mangle::NoGenericParams | Mangle::Type));
-                                        }
-                                }
-                        }
-                        // if candidates are already produced, do not fail
-                        // xxx - is it possible that handleTupleAssignment and main finder both produce candidates?
-                        // this means there exists ctor/assign functions with a tuple as first parameter.
-                        funcFinder.find( untypedExpr->func, selfFinder.candidates.empty() ? ResolvMode::withAdjustment() : ResolvMode::withoutFailFast() );
-                        // short-circuit if no candidates
-                        // if ( funcFinder.candidates.empty() ) return;
-
-                        reason.code = NoMatch;
 
                         // find function operators
@@ -1101 +1066 @@
                                 // unification run for side-effects
                                 unify( toType, cand->expr->result, cand->env, need, have, open, symtab );
-                                Cost thisCost = 
-                                        (castExpr->isGenerated == ast::GeneratedFlag::GeneratedCast)
-                            ? conversionCost( cand->expr->result, toType, cand->expr->get_lvalue(), symtab, cand->env )
-                            : castCost( cand->expr->result, toType, cand->expr->get_lvalue(), symtab, cand->env );
-
+                                Cost thisCost = castCost( cand->expr->result, toType, cand->expr->get_lvalue(),
+                                                symtab, cand->env );
                                 PRINT(
                                         std::cerr << "working on cast with result: " << toType << std::endl;
@@ -1225 +1187 @@
 
                 void postvisit( const ast::NameExpr * nameExpr ) {
-                        std::vector< ast::SymbolTable::IdData > declList;
-                        if (!selfFinder.otypeKeys.empty()) {
-                                auto kind = ast::SymbolTable::getSpecialFunctionKind(nameExpr->name);
-                                assertf(kind != ast::SymbolTable::SpecialFunctionKind::NUMBER_OF_KINDS, "special lookup with non-special target: %s", nameExpr->name.c_str());
-
-                                for (auto & otypeKey: selfFinder.otypeKeys) {
-                                        auto result = symtab.specialLookupId(kind, otypeKey);
-                                        declList.insert(declList.end(), std::make_move_iterator(result.begin()), std::make_move_iterator(result.end()));
-                                }
-                        }
-                        else {
-                                declList = symtab.lookupId( nameExpr->name );
-                        }
+                        std::vector< ast::SymbolTable::IdData > declList = symtab.lookupId( nameExpr->name );
                         PRINT( std::cerr << "nameExpr is " << nameExpr->name << std::endl; )
-
                         if( declList.empty() ) return;
 
@@ -1594 +1543 @@
 
                                         // unification run for side-effects
-                                        bool canUnify = unify( toType, cand->expr->result, env, need, have, open, symtab );
-                                        (void) canUnify;
+                                        unify( toType, cand->expr->result, env, need, have, open, symtab );
                                         Cost thisCost = computeConversionCost( cand->expr->result, toType, cand->expr->get_lvalue(),
-                                                symtab, env );
-                                        PRINT(
-                                                Cost legacyCost = castCost( cand->expr->result, toType, cand->expr->get_lvalue(),
                                                         symtab, env );
-                                                std::cerr << "Considering initialization:";
-                                                std::cerr << std::endl << "  FROM: " << cand->expr->result << std::endl;
-                                                std::cerr << std::endl << "  TO: "   << toType             << std::endl;
-                                                std::cerr << std::endl << "  Unification " << (canUnify ? "succeeded" : "failed");
-                                                std::cerr << std::endl << "  Legacy cost " << legacyCost;
-                                                std::cerr << std::endl << "  New cost " << thisCost;
-                                                std::cerr << std::endl;
-                                        )
+
                                         if ( thisCost != Cost::infinity ) {
                                                 // count one safe conversion for each value that is thrown away
@@ -1620 +1558 @@
                                         }
                                 }
-
                         }
 

src/ResolvExpr/CandidateFinder.hpp

@@ -31 +31 @@
         const ast::TypeEnvironment & env;  ///< Substitutions performed in this resolution
         ast::ptr< ast::Type > targetType;  ///< Target type for resolution
-        std::set< std::string > otypeKeys;  /// different type may map to same key
 
         CandidateFinder(

src/ResolvExpr/Resolver.h

@@ -35 +35 @@
         class StmtExpr;
         class SymbolTable;
-        struct TranslationUnit;
+        class TranslationUnit;
         class Type;
         class TypeEnvironment;
@@ -63 +63 @@
         ast::ptr< ast::Expr > resolveInVoidContext(
                 const ast::Expr * expr, const ast::SymbolTable & symtab, ast::TypeEnvironment & env );
-        /// Resolve `untyped` to the single expression whose candidate is the best match for the
+        /// Resolve `untyped` to the single expression whose candidate is the best match for the 
         /// given type.
         ast::ptr< ast::Expr > findSingleExpression(

src/ResolvExpr/SatisfyAssertions.cpp

@@ -167 +167 @@
                 // find candidates that unify with the desired type
                 AssnCandidateList matches;
-
-                std::vector<ast::SymbolTable::IdData> candidates;
-                auto kind = ast::SymbolTable::getSpecialFunctionKind(assn.first->name);
-                if (kind != ast::SymbolTable::SpecialFunctionKind::NUMBER_OF_KINDS) {
-                        // prefilter special decls by argument type, if already known
-                        ast::ptr<ast::Type> thisArgType = strict_dynamic_cast<const ast::PointerType *>(assn.first->get_type())->base
-                                .strict_as<ast::FunctionType>()->params[0]
-                                .strict_as<ast::ReferenceType>()->base;
-                        sat.cand->env.apply(thisArgType);
-
-                        std::string otypeKey = "";
-                        if (thisArgType.as<ast::PointerType>()) otypeKey = Mangle::Encoding::pointer;
-                        else if (!isUnboundType(thisArgType)) otypeKey = Mangle::mangle(thisArgType, Mangle::Type | Mangle::NoGenericParams);
-
-                        candidates = sat.symtab.specialLookupId(kind, otypeKey);
-                }
-                else {
-                        candidates = sat.symtab.lookupId(assn.first->name);
-                }
-                for ( const ast::SymbolTable::IdData & cdata : candidates ) {
+                for ( const ast::SymbolTable::IdData & cdata : sat.symtab.lookupId( assn.first->name ) ) {
                         const ast::DeclWithType * candidate = cdata.id;