Start populating named entities in relevant locations. (#919)

This starts detecting naming collisions as a consequence of being able to determine when the name is declared twice in a given scope.



Co-authored-by: Geoff Romer <gromer@google.com>

executable_semantics/interpreter/resolve_names.cpp

@@ -0,0 +1,198 @@
+// Part of the Carbon Language project, under the Apache License v2.0 with LLVM
+// Exceptions. See /LICENSE for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include "executable_semantics/interpreter/resolve_names.h"
+
+#include "executable_semantics/ast/declaration.h"
+#include "llvm/Support/Casting.h"
+
+using llvm::cast;
+
+namespace Carbon {
+
+namespace {
+
+// Populates names for a pattern. See PopulateNamesInDeclaration for overall
+// flow.
+void PopulateNamesInPattern(const Pattern& pattern, StaticScope& static_scope) {
+  switch (pattern.kind()) {
+    case Pattern::Kind::AlternativePattern: {
+      const auto& alt = cast<AlternativePattern>(pattern);
+      PopulateNamesInPattern(alt.arguments(), static_scope);
+      break;
+    }
+    case Pattern::Kind::BindingPattern: {
+      const auto& binding = cast<BindingPattern>(pattern);
+      if (binding.name().has_value()) {
+        static_scope.Add(*binding.name(), &binding);
+      }
+      break;
+    }
+    case Pattern::Kind::TuplePattern: {
+      const auto& tuple = cast<TuplePattern>(pattern);
+      for (auto* field : tuple.fields()) {
+        PopulateNamesInPattern(*field, static_scope);
+      }
+      break;
+    }
+    case Pattern::Kind::AutoPattern:
+    case Pattern::Kind::ExpressionPattern:
+      // These don't add names.
+      break;
+  }
+}
+
+// Populates names for a statement. See PopulateNamesInDeclaration for overall
+// flow.
+void PopulateNamesInStatement(Arena* arena,
+                              std::optional<Nonnull<Statement*>> opt_statement,
+                              StaticScope& static_scope) {
+  if (!opt_statement.has_value()) {
+    return;
+  }
+  Statement& statement = **opt_statement;
+  switch (statement.kind()) {
+    case Statement::Kind::Block: {
+      // Defines a new scope for names.
+      auto& block = cast<Block>(statement);
+      for (const auto& statement : block.statements()) {
+        PopulateNamesInStatement(arena, statement, block.static_scope());
+      }
+      break;
+    }
+    case Statement::Kind::Continuation: {
+      // Defines a new name and contains a block.
+      auto& cont = cast<Continuation>(statement);
+      static_scope.Add(cont.continuation_variable(), &cont);
+      PopulateNamesInStatement(arena, &cont.body(), static_scope);
+      break;
+    }
+    case Statement::Kind::VariableDefinition: {
+      // Defines a new name.
+      const auto& var = cast<VariableDefinition>(statement);
+      PopulateNamesInPattern(var.pattern(), static_scope);
+      break;
+    }
+    case Statement::Kind::If: {
+      // Contains blocks.
+      auto& if_stmt = cast<If>(statement);
+      PopulateNamesInStatement(arena, &if_stmt.then_block(), static_scope);
+      PopulateNamesInStatement(arena, if_stmt.else_block(), static_scope);
+      break;
+    }
+    case Statement::Kind::While: {
+      // Contains a block.
+      auto& while_stmt = cast<While>(statement);
+      PopulateNamesInStatement(arena, &while_stmt.body(), static_scope);
+      break;
+    }
+    case Statement::Kind::Match: {
+      // Contains blocks.
+      auto& match = cast<Match>(statement);
+      for (auto& clause : match.clauses()) {
+        PopulateNamesInPattern(clause.pattern(), clause.static_scope());
+        PopulateNamesInStatement(arena, &clause.statement(),
+                                 clause.static_scope());
+      }
+      break;
+    }
+    case Statement::Kind::Assign:
+    case Statement::Kind::Await:
+    case Statement::Kind::Break:
+    case Statement::Kind::Continue:
+    case Statement::Kind::ExpressionStatement:
+    case Statement::Kind::Return:
+    case Statement::Kind::Run:
+      // Neither contains names nor a scope.
+      break;
+  }
+}
+
+// Populates names for a member. See PopulateNamesInDeclaration for overall
+// flow.
+void PopulateNamesInMember(Arena* arena, const Member& member,
+                           StaticScope& static_scope) {
+  switch (member.kind()) {
+    case Member::Kind::FieldMember: {
+      const auto& field = cast<FieldMember>(member);
+      if (field.binding().name().has_value()) {
+        static_scope.Add(*field.binding().name(), &member);
+      }
+      break;
+    }
+  }
+}
+
+// Populates declared names at scoped boundaries, such as file-level or
+// function bodies. This doesn't currently recurse into expressions, but
+// likely will in the future in order to resolve names in lambdas.
+void PopulateNamesInDeclaration(Arena* arena, Declaration& declaration,
+                                StaticScope& static_scope) {
+  switch (declaration.kind()) {
+    case Declaration::Kind::FunctionDeclaration: {
+      auto& func = cast<FunctionDeclaration>(declaration);
+      static_scope.Add(func.name(), &declaration);
+      for (const auto& param : func.deduced_parameters()) {
+        func.static_scope().Add(param.name(), &param);
+      }
+      PopulateNamesInPattern(func.param_pattern(), func.static_scope());
+      PopulateNamesInStatement(arena, func.body(), static_scope);
+      break;
+    }
+    case Declaration::Kind::ClassDeclaration: {
+      auto& class_def = cast<ClassDeclaration>(declaration).definition();
+      static_scope.Add(class_def.name(), &declaration);
+      for (auto* member : class_def.members()) {
+        PopulateNamesInMember(arena, *member, class_def.static_scope());
+      }
+      break;
+    }
+    case Declaration::Kind::ChoiceDeclaration: {
+      auto& choice = cast<ChoiceDeclaration>(declaration);
+      static_scope.Add(choice.name(), &declaration);
+      for (auto& alt : choice.alternatives()) {
+        choice.static_scope().Add(alt.name(), &alt);
+      }
+      // Populate name into declared_names.
+      // Init the choice's declared_names, and populate it with the
+      // alternatives.
+      break;
+    }
+    case Declaration::Kind::VariableDeclaration:
+      auto& var = cast<VariableDeclaration>(declaration);
+      if (var.binding().name().has_value()) {
+        static_scope.Add(*(var.binding().name()), &var.binding());
+      }
+      return;
+  }
+}
+
+// TODO: ResolveNames for Expression, Member, Pattern, and Statement will be
+// needed for recursion.
+
+// Recurses through a declaration to find and resolve IdentifierExpressions
+// using declared_names.
+void ResolveNamesInDeclaration(Declaration& declaration,
+                               const StaticScope& static_scope) {
+  switch (declaration.kind()) {
+    case Declaration::Kind::FunctionDeclaration:
+    case Declaration::Kind::ClassDeclaration:
+    case Declaration::Kind::ChoiceDeclaration:
+    case Declaration::Kind::VariableDeclaration:
+      break;
+  }
+}
+
+}  // namespace
+
+void ResolveNames(Arena* arena, AST& ast) {
+  for (auto declaration : ast.declarations) {
+    PopulateNamesInDeclaration(arena, *declaration, ast.static_scope);
+  }
+  for (auto declaration : ast.declarations) {
+    ResolveNamesInDeclaration(*declaration, ast.static_scope);
+  }
+}
+
+}  // namespace Carbon