Move paren_contents under ast and restrict syntax BUILD visibility (#756)

Trying to straighten out the BUILD graph; the dependency of ast pieces on paren_contents makes me think this is the right direction.

executable_semantics/ast/BUILD

@@ -28,11 +28,11 @@ cc_library(
     srcs = ["expression.cpp"],
     hdrs = ["expression.h"],
     deps = [
+        ":paren_contents",
         "//common:indirect_value",
         "//common:ostream",
         "//executable_semantics/common:arena",
         "//executable_semantics/common:error",
-        "//executable_semantics/syntax:paren_contents",
         "@llvm-project//llvm:Support",
     ],
 )
@@ -42,7 +42,7 @@ cc_test(
     srcs = ["expression_test.cpp"],
     deps = [
         ":expression",
-        "//executable_semantics/syntax:paren_contents",
+        ":paren_contents",
         "@llvm-project//llvm:gtest",
         "@llvm-project//llvm:gtest_main",
     ],
@@ -69,6 +69,11 @@ cc_library(
     ],
 )
 
+cc_library(
+    name = "paren_contents",
+    hdrs = ["paren_contents.h"],
+)
+
 cc_library(
     name = "pattern",
     srcs = ["pattern.cpp"],
@@ -86,8 +91,8 @@ cc_test(
     name = "pattern_test",
     srcs = ["pattern_test.cpp"],
     deps = [
+        ":paren_contents",
         ":pattern",
-        "//executable_semantics/syntax:paren_contents",
         "@llvm-project//llvm:Support",
         "@llvm-project//llvm:gtest",
         "@llvm-project//llvm:gtest_main",

executable_semantics/ast/expression.h

@@ -11,7 +11,7 @@
 #include <vector>
 
 #include "common/ostream.h"
-#include "executable_semantics/syntax/paren_contents.h"
+#include "executable_semantics/ast/paren_contents.h"
 #include "llvm/Support/Compiler.h"
 
 namespace Carbon {

executable_semantics/ast/expression_test.cpp

@@ -6,8 +6,8 @@
 
 #include <string>
 
+#include "executable_semantics/ast/paren_contents.h"
 #include "executable_semantics/common/arena.h"
-#include "executable_semantics/syntax/paren_contents.h"
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 #include "llvm/Support/Casting.h"

executable_semantics/ast/paren_contents.h

@@ -0,0 +1,86 @@
+// 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
+
+#ifndef EXECUTABLE_SEMANTICS_AST_PAREN_CONTENTS_H_
+#define EXECUTABLE_SEMANTICS_AST_PAREN_CONTENTS_H_
+
+#include <optional>
+#include <string>
+#include <vector>
+
+#include "executable_semantics/common/error.h"
+
+namespace Carbon {
+
+// Represents the syntactic contents of an expression or pattern delimited by
+// parentheses. In those syntaxes, parentheses can be used either for grouping
+// or for forming a tuple, depending on their context and the syntax of their
+// contents; this class helps calling code resolve that ambiguity. Since that
+// ambiguity is purely syntactic, this class should only be needed during
+// parsing.
+//
+// `Term` is the type of the syntactic grouping being built, and the type of
+// the individual syntactic units it's built from; typically it should be
+// either `Expression` or `Pattern`.
+template <typename Term>
+struct ParenContents {
+  struct Element {
+    std::optional<std::string> name;
+    const Term* term;
+  };
+
+  // If this object represents a single term, with no name and no trailing
+  // comma, this method returns that term. This typically means the parentheses
+  // can be interpreted as grouping.
+  auto SingleTerm() const -> std::optional<const Term*>;
+
+  // Converts `elements` to std::vector<TupleElement>. TupleElement must
+  // have a constructor that takes a std::string and a const Term*.
+  //
+  // TODO: Find a way to deduce TupleElement from Term.
+  template <typename TupleElement>
+  auto TupleElements(int line_num) const -> std::vector<TupleElement>;
+
+  std::vector<Element> elements;
+  bool has_trailing_comma;
+};
+
+// Implementation details only below here.
+
+template <typename Term>
+auto ParenContents<Term>::SingleTerm() const -> std::optional<const Term*> {
+  if (elements.size() == 1 && !elements.front().name.has_value() &&
+      !has_trailing_comma) {
+    return elements.front().term;
+  } else {
+    return std::nullopt;
+  }
+}
+
+template <typename Term>
+template <typename TupleElement>
+auto ParenContents<Term>::TupleElements(int line_num) const
+    -> std::vector<TupleElement> {
+  std::vector<TupleElement> result;
+  int i = 0;
+  bool seen_named_member = false;
+  for (auto element : elements) {
+    if (element.name.has_value()) {
+      seen_named_member = true;
+      result.push_back(TupleElement(*element.name, element.term));
+    } else {
+      if (seen_named_member) {
+        FATAL_PROGRAM_ERROR(line_num)
+            << "positional members must come before named members";
+      }
+      result.push_back(TupleElement(std::to_string(i), element.term));
+    }
+    ++i;
+  }
+  return result;
+}
+
+}  // namespace Carbon
+
+#endif  // EXECUTABLE_SEMANTICS_AST_PAREN_CONTENTS_H_

executable_semantics/ast/pattern_test.cpp

@@ -5,8 +5,8 @@
 #include "executable_semantics/ast/pattern.h"
 
 #include "executable_semantics/ast/expression.h"
+#include "executable_semantics/ast/paren_contents.h"
 #include "executable_semantics/common/arena.h"
-#include "executable_semantics/syntax/paren_contents.h"
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
 #include "llvm/Support/Casting.h"