Simplify symbol bindings

Author: robertoraggi

src/parser/cxx/parser.cc

@@ -744,40 +744,6 @@ struct Parser::ClassSpecifierContext {
   }
 };
 
-struct Parser::DeclareSymbol {
-  Parser* p;
-  Scope* scope_;
-
-  explicit DeclareSymbol(Parser* p, Scope* scope) : p(p), scope_(scope) {}
-
-  auto control() const -> Control* { return p->control_; }
-
-  void operator()(Symbol* symbol) {
-    if (auto f = symbol_cast<FunctionSymbol>(symbol)) {
-      for (Symbol* candidate : scope_->find(symbol->name())) {
-        if (auto currentFunction = symbol_cast<FunctionSymbol>(candidate)) {
-          auto ovl =
-              control()->newOverloadSetSymbol(candidate->enclosingScope(), {});
-          ovl->setName(symbol->name());
-          scope_->replaceSymbol(currentFunction, ovl);
-
-          ovl->addFunction(currentFunction);
-          ovl->addFunction(f);
-
-          return;
-        }
-
-        if (auto ovl = symbol_cast<OverloadSetSymbol>(candidate)) {
-          ovl->addFunction(f);
-          return;
-        }
-      }
-    }
-
-    scope_->addSymbol(symbol);
-  }
-};
-
 Parser::Parser(TranslationUnit* unit) : unit(unit) {
   control_ = unit->control();
   diagnosticClient_ = unit->diagnosticsClient();
@@ -1778,16 +1744,15 @@ auto Parser::parse_lambda_expression(ExpressionAST*& yyast) -> bool {
 
   if (auto params = ast->parameterDeclarationClause) {
     auto lambdaScope = symbol->scope();
-    std::invoke(DeclareSymbol{this, lambdaScope},
-                params->functionParametersSymbol);
+    lambdaScope->addSymbol(params->functionParametersSymbol);
     setScope(params->functionParametersSymbol);
   } else {
     setScope(symbol);
   }
 
   if (!lookat(TokenKind::T_LBRACE)) return false;
 
-  std::invoke(DeclareSymbol{this, scope_}, symbol);
+  scope_->addSymbol(symbol);
 
   if (!parse_compound_statement(ast->statement)) {
     parse_error("expected a compound statement");
@@ -3821,7 +3786,7 @@ void Parser::parse_init_statement(StatementAST*& yyast) {
       for (auto initDeclaraotr :
            ListView(simpleDeclaration->initDeclaratorList)) {
         auto symbol = initDeclaraotr->symbol;
-        std::invoke(DeclareSymbol{this, scope_}, symbol);
+        scope_->addSymbol(symbol);
       }
     }
 
@@ -3986,7 +3951,7 @@ auto Parser::parse_compound_statement(CompoundStatementAST*& yyast, bool skip)
   ScopeGuard scopeGuard{this};
 
   auto blockSymbol = control_->newBlockSymbol(scope_, lbraceLoc);
-  std::invoke(DeclareSymbol{this, scope_}, blockSymbol);
+  scope_->addSymbol(blockSymbol);
   setScope(blockSymbol);
 
   auto ast = make_node<CompoundStatementAST>(pool_);
@@ -4070,7 +4035,7 @@ auto Parser::parse_if_statement(StatementAST*& yyast) -> bool {
   ScopeGuard scopeGuard{this};
 
   auto blockSymbol = control_->newBlockSymbol(scope_, ifLoc);
-  std::invoke(DeclareSymbol{this, scope_}, blockSymbol);
+  scope_->addSymbol(blockSymbol);
   setScope(blockSymbol);
 
   if (LA().isOneOf(TokenKind::T_EXCLAIM, TokenKind::T_CONSTEVAL)) {
@@ -4153,7 +4118,7 @@ auto Parser::parse_while_statement(StatementAST*& yyast) -> bool {
   ScopeGuard scopeGuard{this};
 
   auto blockSymbol = control_->newBlockSymbol(scope_, whileLoc);
-  std::invoke(DeclareSymbol{this, scope_}, blockSymbol);
+  scope_->addSymbol(blockSymbol);
   setScope(blockSymbol);
 
   auto ast = make_node<WhileStatementAST>(pool_);
@@ -4224,7 +4189,7 @@ auto Parser::parse_for_range_statement(StatementAST*& yyast) -> bool {
 
   lookahead.commit();
 
-  std::invoke(DeclareSymbol{this, scope_}, blockSymbol);
+  scope_->addSymbol(blockSymbol);
 
   auto ast = make_node<ForRangeStatementAST>(pool_);
   yyast = ast;
@@ -4254,7 +4219,7 @@ auto Parser::parse_for_statement(StatementAST*& yyast) -> bool {
   ScopeGuard scopeGuard{this};
 
   auto blockSymbol = control_->newBlockSymbol(scope_, forLoc);
-  std::invoke(DeclareSymbol{this, scope_}, blockSymbol);
+  scope_->addSymbol(blockSymbol);
   setScope(blockSymbol);
 
   auto ast = make_node<ForStatementAST>(pool_);
@@ -4602,7 +4567,7 @@ auto Parser::enterOrCreateNamespace(const Identifier* identifier,
 
     namespaceSymbol->setInline(isInline);
 
-    std::invoke(DeclareSymbol{this, parentScope}, namespaceSymbol);
+    parentScope->addSymbol(namespaceSymbol);
 
     if (isInline || !namespaceSymbol->name()) {
       parentNamespace->scope()->addUsingDirective(namespaceSymbol->scope());
@@ -4903,8 +4868,7 @@ auto Parser::parse_simple_declaration(
 
     if (auto params = functionDeclarator->parameterDeclarationClause) {
       auto functionScope = functionSymbol->scope();
-      std::invoke(DeclareSymbol{this, functionScope},
-                  params->functionParametersSymbol);
+      functionScope->addSymbol(params->functionParametersSymbol);
       setScope(params->functionParametersSymbol);
     } else {
       setScope(functionSymbol);
@@ -5064,8 +5028,7 @@ auto Parser::parse_notypespec_function_definition(
 
   if (auto params = functionDeclarator->parameterDeclarationClause) {
     auto functionScope = functionSymbol->scope();
-    std::invoke(DeclareSymbol{this, functionScope},
-                params->functionParametersSymbol);
+    functionScope->addSymbol(params->functionParametersSymbol);
     setScope(params->functionParametersSymbol);
   } else {
     setScope(functionSymbol);
@@ -7415,7 +7378,7 @@ auto Parser::parse_parameter_declaration(ParameterDeclarationAST*& yyast,
         control_->newParameterSymbol(scope_, decl.location());
     parameterSymbol->setName(ast->identifier);
     parameterSymbol->setType(ast->type);
-    std::invoke(DeclareSymbol{this, scope_}, parameterSymbol);
+    scope_->addSymbol(parameterSymbol);
   }
 
   if (match(TokenKind::T_EQUAL, ast->equalLoc)) {
@@ -7767,7 +7730,7 @@ auto Parser::parse_enum_specifier(SpecifierAST*& yyast, DeclSpecs& specs)
 
     enumSymbol->setName(enumName);
     enumSymbol->setUnderlyingType(underlyingType);
-    std::invoke(DeclareSymbol{this, scope_}, enumSymbol);
+    scope_->addSymbol(enumSymbol);
 
     setScope(enumSymbol);
   } else {
@@ -7776,7 +7739,7 @@ auto Parser::parse_enum_specifier(SpecifierAST*& yyast, DeclSpecs& specs)
 
     enumSymbol->setName(enumName);
     enumSymbol->setUnderlyingType(underlyingType);
-    std::invoke(DeclareSymbol{this, scope_}, enumSymbol);
+    scope_->addSymbol(enumSymbol);
 
     setScope(enumSymbol);
   }
@@ -7935,7 +7898,7 @@ void Parser::parse_enumerator(EnumeratorAST*& yyast, const Type* type) {
   enumeratorSymbol->setType(type);
   enumeratorSymbol->setValue(value);
 
-  std::invoke(DeclareSymbol{this, scope_}, enumeratorSymbol);
+  scope_->addSymbol(enumeratorSymbol);
 
   if (auto enumSymbol = symbol_cast<EnumSymbol>(scope_->owner())) {
     auto enumeratorSymbol =
@@ -7945,7 +7908,7 @@ void Parser::parse_enumerator(EnumeratorAST*& yyast, const Type* type) {
     enumeratorSymbol->setValue(value);
 
     auto parentScope = enumSymbol->enclosingScope();
-    std::invoke(DeclareSymbol{this, parentScope}, enumeratorSymbol);
+    parentScope->addSymbol(enumeratorSymbol);
   }
 }
 
@@ -8283,7 +8246,7 @@ auto Parser::parse_using_declarator(UsingDeclaratorAST*& yyast) -> bool {
   symbol->setDeclarator(yyast);
   symbol->setTarget(target);
 
-  std::invoke(DeclareSymbol{this, scope_}, symbol);
+  scope_->addSymbol(symbol);
 
   return true;
 }
@@ -9255,7 +9218,7 @@ auto Parser::parse_class_head(ClassHead& classHead) -> bool {
     classSymbol->setName(identifier);
     classSymbol->setTemplateParameters(currentTemplateParameters());
 
-    std::invoke(DeclareSymbol{this, declaringScope()}, classSymbol);
+    declaringScope()->addSymbol(classSymbol);
   }
 
   classHead.symbol = classSymbol;
@@ -9424,8 +9387,7 @@ auto Parser::parse_member_declaration_helper(DeclarationAST*& yyast) -> bool {
 
     if (auto params = functionDeclarator->parameterDeclarationClause) {
       auto functionScope = functionSymbol->scope();
-      std::invoke(DeclareSymbol{this, functionScope},
-                  params->functionParametersSymbol);
+      functionScope->addSymbol(params->functionParametersSymbol);
       setScope(params->functionParametersSymbol);
     } else {
       setScope(functionSymbol);
@@ -9564,25 +9526,26 @@ auto Parser::declareTypeAlias(SourceLocation identifierLoc, TypeIdAST* typeId)
   symbol->setName(name);
   if (typeId) symbol->setType(typeId->type);
   symbol->setTemplateParameters(currentTemplateParameters());
-  std::invoke(DeclareSymbol{this, declaringScope()}, symbol);
+  declaringScope()->addSymbol(symbol);
   return symbol;
 }
 
 auto Parser::declareTypedef(DeclaratorAST* declarator, const Decl& decl)
     -> TypeAliasSymbol* {
   auto name = decl.getName();
   auto type = GetDeclaratorType{this}(declarator, decl.specs.getType());
-  auto typedefSymbol = control_->newTypeAliasSymbol(scope_, decl.location());
-  typedefSymbol->setName(name);
-  typedefSymbol->setType(type);
-  std::invoke(DeclareSymbol{this, scope_}, typedefSymbol);
-  return typedefSymbol;
+  auto symbol = control_->newTypeAliasSymbol(scope_, decl.location());
+  symbol->setName(name);
+  symbol->setType(type);
+  scope_->addSymbol(symbol);
+  return symbol;
 }
 
 auto Parser::declareFunction(DeclaratorAST* declarator, const Decl& decl)
     -> FunctionSymbol* {
   auto name = decl.getName();
   auto type = GetDeclaratorType{this}(declarator, decl.specs.getType());
+
   auto functionSymbol = control_->newFunctionSymbol(scope_, decl.location());
   applySpecifiers(functionSymbol, decl.specs);
   functionSymbol->setName(name);
@@ -9595,8 +9558,31 @@ auto Parser::declareFunction(DeclaratorAST* declarator, const Decl& decl)
     if (enclosingClass) {
       enclosingClass->addConstructor(functionSymbol);
     }
+
+    return functionSymbol;
+  }
+
+  auto scope = declaringScope();
+
+  OverloadSetSymbol* overloadSet = nullptr;
+
+  for (Symbol* candidate : scope->find(functionSymbol->name())) {
+    overloadSet = symbol_cast<OverloadSetSymbol>(candidate);
+    if (overloadSet) break;
+
+    if (auto previousFunction = symbol_cast<FunctionSymbol>(candidate)) {
+      overloadSet = control_->newOverloadSetSymbol(scope, {});
+      overloadSet->setName(functionSymbol->name());
+      overloadSet->addFunction(previousFunction);
+      scope_->replaceSymbol(previousFunction, overloadSet);
+      break;
+    }
+  }
+
+  if (overloadSet) {
+    overloadSet->addFunction(functionSymbol);
   } else {
-    std::invoke(DeclareSymbol{this, declaringScope()}, functionSymbol);
+    scope->addSymbol(functionSymbol);
   }
 
   return functionSymbol;
@@ -9610,7 +9596,7 @@ auto Parser::declareField(DeclaratorAST* declarator, const Decl& decl)
   applySpecifiers(fieldSymbol, decl.specs);
   fieldSymbol->setName(name);
   fieldSymbol->setType(type);
-  std::invoke(DeclareSymbol{this, scope_}, fieldSymbol);
+  scope_->addSymbol(fieldSymbol);
   return fieldSymbol;
 }
 
@@ -9624,7 +9610,7 @@ auto Parser::declareVariable(DeclaratorAST* declarator, const Decl& decl,
   symbol->setType(type);
   symbol->setTemplateParameters(currentTemplateParameters());
   if (ctx != BindingContext::kInitStatement) {
-    std::invoke(DeclareSymbol{this, declaringScope()}, symbol);
+    declaringScope()->addSymbol(symbol);
   }
   return symbol;
 }
@@ -10397,7 +10383,7 @@ void Parser::parse_template_parameter(TemplateParameterAST*& yyast) {
   symbol->setName(parameter->identifier);
   symbol->setParameterPack(parameter->isPack);
   symbol->setObjectType(parameter->type);
-  std::invoke(DeclareSymbol{this, scope_}, symbol);
+  scope_->addSymbol(symbol);
 
   auto ast = make_node<NonTypeTemplateParameterAST>(pool_);
   yyast = ast;
@@ -10454,7 +10440,7 @@ auto Parser::parse_typename_type_parameter(TemplateParameterAST*& yyast)
   symbol->setDepth(templateParameterDepth_);
   symbol->setParameterPack(isPack);
   symbol->setName(ast->identifier);
-  std::invoke(DeclareSymbol{this, scope_}, symbol);
+  scope_->addSymbol(symbol);
 
   ast->symbol = symbol;
 
@@ -10515,7 +10501,7 @@ void Parser::parse_template_type_parameter(TemplateParameterAST*& yyast) {
     mark_maybe_template_name(ast->identifier);
   }
 
-  std::invoke(DeclareSymbol{this, scope_}, symbol);
+  scope_->addSymbol(symbol);
 
   if (match(TokenKind::T_EQUAL, ast->equalLoc)) {
     if (!parse_id_expression(ast->idExpression,
@@ -10564,7 +10550,7 @@ auto Parser::parse_constraint_type_parameter(TemplateParameterAST*& yyast)
   symbol->setIndex(templateParameterCount_);
   symbol->setDepth(templateParameterDepth_);
   symbol->setName(ast->identifier);
-  std::invoke(DeclareSymbol{this, scope_}, symbol);
+  scope_->addSymbol(symbol);
 
   return true;
 }
@@ -10972,7 +10958,7 @@ auto Parser::parse_concept_definition(DeclarationAST*& yyast) -> bool {
   symbol->setName(ast->identifier);
   symbol->setTemplateParameters(templateParameters);
 
-  std::invoke(DeclareSymbol{this, declaringScope()}, symbol);
+  declaringScope()->addSymbol(symbol);
 
   if (ast->identifierLoc) {
     concept_names_.insert(ast->identifier);

src/parser/cxx/parser.h

@@ -79,7 +79,6 @@ class Parser final {
   struct LoopParser;
   struct ClassHead;
   struct GetDeclaratorType;
-  struct DeclareSymbol;
 
   enum struct BindingContext {
     kNamespace,

src/parser/cxx/scope.cc

@@ -66,12 +66,11 @@ void Scope::addSymbol(Symbol* symbol) {
     return;
   }
 
-  if (auto templateParameters = symbol_cast<TemplateParametersSymbol>(owner_)) {
+  if (isTemplateParametersScope()) {
     if (!(symbol->isTypeParameter() || symbol->isTemplateTypeParameter() ||
           symbol->isNonTypeParameter() ||
           symbol->isConstraintTypeParameter())) {
-      cxx_runtime_error(
-          "invalid symbol in template parameters scope");
+      cxx_runtime_error("invalid symbol in template parameters scope");
     }
   }