[clang-format] Add Basic Carbon Support/Infrastructure to clang-format

[MyDeveloperDay]

Summary

Its great when clang-format is the ubiquitous tool for all formatting regardless of the language. clang-formats existing integration into common editors/IDEs means we can build on the clang-format legacy to help contribute in a small way to the future of Carbon, simply by helping providing native Carbon support.

Following the excellent talk by @chandlerc et al at CppNorth (https://www.youtube.com/watch?v=omrY53kbVoA). On seeing the suggested syntax it was clear that clang-format would face some new challenges. (which might be exciting to work on)

This review is to add the basic infrastructure for Carbon as a potential clang-format language, to begin building that infrastructure and to fix a couple of Annotator issues which caused problems even with the simple language examples, namely "spaces around trailing return arrows and an additional space between type and colon in variable declarations"

I'm mainly submitting this to gauge interest from the team, and to see if others feel this might be something that we are interested in pursuing. (its also a good way to learn about Carbon.)

[MyDeveloperDay]

Ensure the colon stick with the variable declaration in a loop

for (var name: String in names) {
   Console.Print(name);
 }

[MyDeveloperDay]

Treat a class like a C# or Javascript class there is no semi after the brace };

class Sum {
  var a: i32;
  fn Add[me:Self](var num: i32) -> i32 {
    var total: i32 = me.a + num;
    return total;
  }
}
fn Main() -> i32 {
  var p1: Sum = {.a = 5};
  var total: i32 = p1.Add(5);
  Print("Total sum {0}", total);
  return 0;
}

[MyDeveloperDay]

Fix pointer function arguments
Add release notes
Fix more TT_TrailingReturnArrow cases

[MyDeveloperDay]

Remove .clang-format change

[MyDeveloperDay]

Improve the handling of generics.
Ensure match is formatted like switch.
Move closer to Google style.
Add some pointer support for return types
Add additional integration

[HazardyKnusperkeks]

clang/lib/Format/UnwrappedLineParser.cpp

3671

[MyDeveloperDay]

@HazardyKnusperkeks thank you, any thoughts from you or others on if you feel its ok for me to continue?

[owenpan]

I'm not against extending clang-format to support yet another language like Carbon, but we should probably wait until it has gained widespread usage?

[rymiel]

I think the above is especially relevant as Carbon may yet change everything about its syntax; for example, in this patch, me has been made a keyword, but that may change in the future: https://github.com/carbon-language/carbon-lang/pull/1382

[MyDeveloperDay]

I'm not actually really considering the new "keywords" much at the moment (less match), some of this is really about formatting the Carbon fundamentals (SpaceBetween etc..) to a Google style.

clang/docs/ClangFormatStyleOptions.rst

 **Language** (``LanguageKind``) :versionbadge:`clang-format 3.5`
   Language, this format style is targeted at.
 
   Possible values:
 
   * ``LK_None`` (in configuration: ``None``)
     Do not use.
 
+  * ``LK_Carbon`` (in configuration: ``Carbon``)
+    Should be used for Carbon
+
   * ``LK_Cpp`` (in configuration: ``Cpp``)
     Should be used for C, C++.
 
   * ``LK_CSharp`` (in configuration: ``CSharp``)
     Should be used for C#.
 
   * ``LK_Java`` (in configuration: ``Java``)
     Should be used for Java.

clang/docs/ReleaseNotes.rst

 Build System Changes
 --------------------
 
 AST Matchers
 ------------
 
 clang-format
 ------------
+- Basic Carbon Language Support.
 
 clang-extdef-mapping
 --------------------
 
 libclang
 --------
 - Introduced the new function ``clang_getUnqualifiedType``, which mimics
   the behavior of ``QualType::getUnqualifiedType`` for ``CXType``.

clang/include/clang/Format/Format.h

   /// Supported languages.
   ///
   /// When stored in a configuration file, specifies the language, that the
   /// configuration targets. When passed to the ``reformat()`` function, enables
   /// syntax features specific to the language.
   enum LanguageKind : int8_t {
     /// Do not use.
     LK_None,
+    /// Should be used for Carbon
+    LK_Carbon,
     /// Should be used for C, C++.
     LK_Cpp,
     /// Should be used for C#.
     LK_CSharp,
     /// Should be used for Java.
     LK_Java,
     /// Should be used for JavaScript.
     LK_JavaScript,
enum LanguageKind : int8_t {
     LK_TextProto,
     /// Should be used for Verilog and SystemVerilog.
     /// https://standards.ieee.org/ieee/1800/6700/
     /// https://sci-hub.st/10.1109/IEEESTD.2018.8299595
     LK_Verilog
   };
   bool isCpp() const { return Language == LK_Cpp || Language == LK_ObjC; }
   bool isCSharp() const { return Language == LK_CSharp; }
+  bool isCarbon() const { return Language == LK_Carbon; }
   bool isJson() const { return Language == LK_Json; }
   bool isJavaScript() const { return Language == LK_JavaScript; }
   bool isVerilog() const { return Language == LK_Verilog; }
 
   /// Language, this format style is targeted at.
   /// \version 3.5
   LanguageKind Language;
 

 // Defaults to FormatStyle::LK_Cpp.
 FormatStyle::LanguageKind guessLanguage(StringRef FileName, StringRef Code);
 
 // Returns a string representation of ``Language``.
 inline StringRef getLanguageName(FormatStyle::LanguageKind Language) {
   switch (Language) {
   case FormatStyle::LK_Cpp:
     return "C++";
+  case FormatStyle::LK_Carbon:
+    return "Carbon";
   case FormatStyle::LK_CSharp:
     return "CSharp";
   case FormatStyle::LK_ObjC:
     return "Objective-C";
   case FormatStyle::LK_Java:
     return "Java";
   case FormatStyle::LK_JavaScript:
     return "JavaScript";

clang/lib/Format/Format.cpp

 
 LLVM_YAML_IS_SEQUENCE_VECTOR(clang::format::FormatStyle::RawStringFormat)
 
 namespace llvm {
 namespace yaml {
 template <> struct ScalarEnumerationTraits<FormatStyle::LanguageKind> {
   static void enumeration(IO &IO, FormatStyle::LanguageKind &Value) {
     IO.enumCase(Value, "Cpp", FormatStyle::LK_Cpp);
+    IO.enumCase(Value, "Carbon", FormatStyle::LK_Carbon);
+    IO.enumCase(Value, "CSharp", FormatStyle::LK_CSharp);
     IO.enumCase(Value, "Java", FormatStyle::LK_Java);
     IO.enumCase(Value, "JavaScript", FormatStyle::LK_JavaScript);
+    IO.enumCase(Value, "Json", FormatStyle::LK_Json);
     IO.enumCase(Value, "ObjC", FormatStyle::LK_ObjC);
     IO.enumCase(Value, "Proto", FormatStyle::LK_Proto);
     IO.enumCase(Value, "TableGen", FormatStyle::LK_TableGen);
     IO.enumCase(Value, "TextProto", FormatStyle::LK_TextProto);
-    IO.enumCase(Value, "CSharp", FormatStyle::LK_CSharp);
-    IO.enumCase(Value, "Json", FormatStyle::LK_Json);
   }
 };
 
 template <> struct ScalarEnumerationTraits<FormatStyle::LanguageStandard> {
   static void enumeration(IO &IO, FormatStyle::LanguageStandard &Value) {
     IO.enumCase(Value, "c++03", FormatStyle::LS_Cpp03);
     IO.enumCase(Value, "C++03", FormatStyle::LS_Cpp03); // Legacy alias
     IO.enumCase(Value, "Cpp03", FormatStyle::LS_Cpp03); // Legacy alias
if (Language == FormatStyle::LK_Java) {
     GoogleStyle.IncludeStyle.IncludeBlocks =
         tooling::IncludeStyle::IBS_Preserve;
   } else if (Language == FormatStyle::LK_CSharp) {
     GoogleStyle.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Empty;
     GoogleStyle.AllowShortIfStatementsOnASingleLine = FormatStyle::SIS_Never;
     GoogleStyle.BreakStringLiterals = false;
     GoogleStyle.ColumnLimit = 100;
     GoogleStyle.NamespaceIndentation = FormatStyle::NI_All;
+  } else if (Language == FormatStyle::LK_Carbon) {
+    GoogleStyle.PointerAlignment = FormatStyle::PAS_Left;
+    GoogleStyle.ReflowComments = false;
   }
 
   return GoogleStyle;
 }
 
 FormatStyle getChromiumStyle(FormatStyle::LanguageKind Language) {
   FormatStyle ChromiumStyle = getGoogleStyle(Language);
 
if (FileName.endswith_insensitive(".textpb") ||
       FileName.endswith_insensitive(".textproto") ||
       FileName.endswith_insensitive(".asciipb")) {
     return FormatStyle::LK_TextProto;
   }
   if (FileName.endswith_insensitive(".td"))
     return FormatStyle::LK_TableGen;
   if (FileName.endswith_insensitive(".cs"))
     return FormatStyle::LK_CSharp;
+  if (FileName.endswith_insensitive(".carbon"))
+    return FormatStyle::LK_Carbon;
   if (FileName.endswith_insensitive(".json"))
     return FormatStyle::LK_Json;
   if (FileName.endswith_insensitive(".sv") ||
       FileName.endswith_insensitive(".svh") ||
       FileName.endswith_insensitive(".v") ||
       FileName.endswith_insensitive(".vh")) {
     return FormatStyle::LK_Verilog;
   }

clang/lib/Format/FormatToken.h

AdditionalKeywords(IdentifierTable &IdentTable) {
     kw_wand = &IdentTable.get("wand");
     kw_weak0 = &IdentTable.get("weak0");
     kw_weak1 = &IdentTable.get("weak1");
     kw_wildcard = &IdentTable.get("wildcard");
     kw_wire = &IdentTable.get("wire");
     kw_with = &IdentTable.get("with");
     kw_wor = &IdentTable.get("wor");
 
+    // Carbon keywords
+    kw_me = &IdentTable.get("me");
+    kw_fn = &IdentTable.get("fn");
+    kw_match = &IdentTable.get("match");
+
     // Symbols that are treated as keywords.
     kw_verilogHash = &IdentTable.get("#");
     kw_verilogHashHash = &IdentTable.get("##");
     kw_apostrophe = &IdentTable.get("\'");
 
     // Keep this at the end of the constructor to make sure everything here
     // is
     // already initialized.
CSharpExtraKeywords = std::unordered_set<IdentifierInfo *>(
          kw_when, kw_where,
          // Keywords from the JavaScript section.
          kw_as, kw_async, kw_await, kw_declare, kw_finally, kw_from,
          kw_function, kw_get, kw_import, kw_is, kw_let, kw_module, kw_readonly,
          kw_set, kw_type, kw_typeof, kw_var, kw_yield,
          // Keywords from the Java section.
          kw_abstract, kw_extends, kw_implements, kw_instanceof, kw_interface});
 
+    CarbonExtraKeywords = std::unordered_set<IdentifierInfo *>(
+        {kw_me, kw_package, kw_fn, kw_abstract});
+
     // Some keywords are not included here because they don't need special
     // treatment like `showcancelled` or they should be treated as identifiers
     // like `int` and `logic`.
     VerilogExtraKeywords =
         std::unordered_set<IdentifierInfo *>({kw_always,
                                               kw_always_comb,
                                               kw_always_ff,
                                               kw_always_latch,
struct AdditionalKeywords {
   IdentifierInfo *kw_uint;
   IdentifierInfo *kw_ulong;
   IdentifierInfo *kw_unchecked;
   IdentifierInfo *kw_unsafe;
   IdentifierInfo *kw_ushort;
   IdentifierInfo *kw_when;
   IdentifierInfo *kw_where;
 
+  // Carbon keywords
+  IdentifierInfo *kw_me;
+  IdentifierInfo *kw_fn;
+  IdentifierInfo *kw_match;
+
   // Verilog keywords
   IdentifierInfo *kw_always;
   IdentifierInfo *kw_always_comb;
   IdentifierInfo *kw_always_ff;
   IdentifierInfo *kw_always_latch;
   IdentifierInfo *kw_assign;
   IdentifierInfo *kw_assume;
   IdentifierInfo *kw_automatic;
private:
   /// The JavaScript keywords beyond the C++ keyword set.
   std::unordered_set<IdentifierInfo *> JsExtraKeywords;
 
   /// The C# keywords beyond the C++ keyword set
   std::unordered_set<IdentifierInfo *> CSharpExtraKeywords;
 
   /// The Verilog keywords beyond the C++ keyword set.
   std::unordered_set<IdentifierInfo *> VerilogExtraKeywords;
+
+  /// The Carbon keywords beyond the C++ keyword set
+  std::unordered_set<IdentifierInfo *> CarbonExtraKeywords;
 };
 
 } // namespace format
 } // namespace clang
 
 #endif

clang/lib/Format/TokenAnnotator.cpp

bool StartsObjCMethodExpr =
           prec::Unknown));
     bool ColonFound = false;
 
     unsigned BindingIncrease = 1;
     if (IsCppStructuredBinding) {
       Left->setType(TT_StructuredBindingLSquare);
     } else if (Left->is(TT_Unknown)) {
       if (StartsObjCMethodExpr) {
+        if (Style.isCarbon())
+          Left->setType(TT_JsTypeColon);
+        else
           Left->setType(TT_ObjCMethodExpr);
       } else if (InsideInlineASM) {
         Left->setType(TT_InlineASMSymbolicNameLSquare);
       } else if (IsCpp11AttributeSpecifier) {
         Left->setType(TT_AttributeSquare);
       } else if (Style.isJavaScript() && Parent &&
                  Contexts.back().ContextKind == tok::l_brace &&
                  Parent->isOneOf(tok::l_brace, tok::comma)) {
         Left->setType(TT_JsComputedPropertyName);
while (CurrentToken) {
         return false;
       if (CurrentToken->is(tok::colon)) {
         if (IsCpp11AttributeSpecifier &&
             CurrentToken->endsSequence(tok::colon, tok::identifier,
                                        tok::kw_using)) {
           // Remember that this is a [[using ns: foo]] C++ attribute, so we
           // don't add a space before the colon (unlike other colons).
           CurrentToken->setType(TT_AttributeColon);
-        } else if (!Style.isVerilog() &&
+        } else if (!Style.isVerilog() && !Style.isCarbon() &&
                    Left->isOneOf(TT_ArraySubscriptLSquare,
                                  TT_DesignatedInitializerLSquare)) {
           Left->setType(TT_ObjCMethodExpr);
           StartsObjCMethodExpr = true;
           Contexts.back().ColonIsObjCMethodExpr = true;
           if (Parent && Parent->is(tok::r_paren)) {
             // FIXME(bug 36976): ObjC return types shouldn't use TT_CastRParen.
             Parent->setType(TT_CastRParen);
           }
+        } else if (Style.isCarbon()) {
+          CurrentToken->setType(TT_JsTypeColon);
         }
         ColonFound = true;
       }
       if (CurrentToken->is(tok::comma) && Left->is(TT_ObjCMethodExpr) &&
           !ColonFound) {
         Left->setType(TT_ArrayInitializerLSquare);
       }
       FormatToken *Tok = CurrentToken;
case tok::colon:
       }
       if (Line.First->isOneOf(Keywords.kw_module, Keywords.kw_import) ||
           Line.First->startsSequence(tok::kw_export, Keywords.kw_module) ||
           Line.First->startsSequence(tok::kw_export, Keywords.kw_import)) {
         Tok->setType(TT_ModulePartitionColon);
       } else if (Contexts.back().ColonIsDictLiteral ||
                  Style.Language == FormatStyle::LK_Proto ||
                  Style.Language == FormatStyle::LK_TextProto) {
+        if (Style.isCarbon())
+          Tok->setType(TT_JsTypeColon);
+        else
           Tok->setType(TT_DictLiteral);
         if (Style.Language == FormatStyle::LK_TextProto) {
           if (FormatToken *Previous = Tok->getPreviousNonComment())
             Previous->setType(TT_SelectorName);
         }
       } else if (Contexts.back().ColonIsObjCMethodExpr ||
                  Line.startsWith(TT_ObjCMethodSpecifier)) {
         Tok->setType(TT_ObjCMethodExpr);
         const FormatToken *BeforePrevious = Tok->Previous->Previous;
case tok::colon:
             Contexts.back().LongestObjCSelectorName =
                 Tok->Previous->ColumnWidth;
           }
           Tok->Previous->ParameterIndex =
               Contexts.back().FirstObjCSelectorName->ObjCSelectorNameParts;
           ++Contexts.back().FirstObjCSelectorName->ObjCSelectorNameParts;
         }
       } else if (Contexts.back().ColonIsForRangeExpr) {
+        if (Style.isCarbon())
+          Tok->setType(TT_JsTypeColon);
+        else
           Tok->setType(TT_RangeBasedForLoopColon);
       } else if (CurrentToken && CurrentToken->is(tok::numeric_constant)) {
         Tok->setType(TT_BitFieldColon);
       } else if (Contexts.size() == 1 &&
                  !Line.First->isOneOf(tok::kw_enum, tok::kw_case,
                                       tok::kw_default)) {
         FormatToken *Prev = Tok->getPreviousNonComment();
         if (!Prev)
           break;
         if (Prev->isOneOf(tok::r_paren, tok::kw_noexcept) ||
             Prev->ClosesRequiresClause) {
           Tok->setType(TT_CtorInitializerColon);
         } else if (Prev->is(tok::kw_try)) {
           // Member initializer list within function try block.
           FormatToken *PrevPrev = Prev->getPreviousNonComment();
           if (!PrevPrev)
             break;
           if (PrevPrev && PrevPrev->isOneOf(tok::r_paren, tok::kw_noexcept))
             Tok->setType(TT_CtorInitializerColon);
         } else {
+          if (Style.isCarbon())
+            Tok->setType(TT_JsTypeColon);
+          else
             Tok->setType(TT_InheritanceColon);
         }
       } else if (canBeObjCSelectorComponent(*Tok->Previous) && Tok->Next &&
                  (Tok->Next->isOneOf(tok::r_paren, tok::comma) ||
                   (canBeObjCSelectorComponent(*Tok->Next) && Tok->Next->Next &&
                    Tok->Next->Next->is(tok::colon)))) {
         // This handles a special macro in ObjC code where selectors including
         // the colon are passed as macro arguments.
         Tok->setType(TT_ObjCMethodExpr);
       } else if (Contexts.back().ContextKind == tok::l_paren) {
+        if (Style.isCarbon())
+          Tok->setType(TT_JsTypeColon);
+        else
           Tok->setType(TT_InlineASMColon);
       }
       break;
     case tok::pipe:
     case tok::amp:
       // | and & in declarations/type expressions represent union and
       // intersection types, respectively.
       if (Style.isJavaScript() && !Contexts.back().IsExpression)
         Tok->setType(TT_JsTypeOperator);
if ((Style.isJavaScript() || Style.isCSharp()) &&
       }
       if (Current.Next &&
           Current.Next->isOneOf(TT_BinaryOperator, Keywords.kw_as)) {
         Current.setType(TT_NonNullAssertion);
         return;
       }
     }
 
+    if (Style.isCarbon()) {
+      // -> T {
+      // -> T ;
+      // -> i32*;
+      if (Current.is(tok::arrow) && Current.Next->Next &&
+          Current.Next->Next->isOneOf(TT_FunctionLBrace, tok::semi,
+                                      tok::star)) {
+        Current.setType(TT_TrailingReturnArrow);
+      }
+      // -> (Self,T) {
+      if (Current.is(tok::arrow) && Current.Next &&
+          Current.Next->is(tok::l_paren)) {
+        Current.setType(TT_TrailingReturnArrow);
+      }
+    }
+
     // Line.MightBeFunctionDecl can only be true after the parentheses of a
     // function declaration have been found. In this case, 'Current' is a
     // trailing token of this declaration and thus cannot be a name.
     if (Current.is(Keywords.kw_instanceof)) {
       Current.setType(TT_BinaryOperator);
     } else if (isStartOfName(Current) &&
                (!Line.MightBeFunctionDecl || Current.NestingLevel != 0)) {
       Contexts.back().FirstStartOfName = &Current;
if (Style.isCSharp() && Tok.is(tok::ampamp))
       return TT_BinaryOperator;
 
     const FormatToken *PrevToken = Tok.getPreviousNonComment();
     if (!PrevToken)
       return TT_UnaryOperator;
 
     const FormatToken *NextToken = Tok.getNextNonComment();
 
+    // handle [addr me: Point*]
+    if (Style.isCarbon() && NextToken->is(tok::r_square))
+      return TT_PointerOrReference;
+
     if (InTemplateArgument && NextToken && NextToken->is(tok::kw_noexcept))
       return TT_BinaryOperator;
 
     if (!NextToken ||
         NextToken->isOneOf(tok::arrow, tok::equal, tok::kw_noexcept) ||
         NextToken->canBePointerOrReferenceQualifier() ||
         (NextToken->is(tok::l_brace) && !NextToken->getNextNonComment())) {
       return TT_PointerOrReference;
bool TokenAnnotator::spaceRequiredBetween(const AnnotatedLine &Line,
   if (Left.is(tok::kw_return) &&
       !Right.isOneOf(tok::semi, tok::r_paren, tok::hashhash)) {
     return true;
   }
   if (Left.is(tok::kw_throw) && Right.is(tok::l_paren) && Right.MatchingParen &&
       Right.MatchingParen->is(TT_CastRParen)) {
     return true;
   }
+  // (T:! Addable)
+  if (Style.isCarbon()) {
+    if (Left.is(TT_JsTypeColon) && Right.is(tok::exclaim))
+      return false;
+    if (Left.is(tok::exclaim) && Left.Previous &&
+        Left.Previous->is(TT_JsTypeColon)) {
+      return true;
+    }
+  }
   if (Style.isJson() && Left.is(tok::string_literal) && Right.is(tok::colon))
     return false;
   if (Left.is(Keywords.kw_assert) && Style.Language == FormatStyle::LK_Java)
     return true;
   if (Style.ObjCSpaceAfterProperty && Line.Type == LT_ObjCProperty &&
       Left.Tok.getObjCKeywordID() == tok::objc_property) {
     return true;
   }
bool TokenAnnotator::spaceRequiredBetween(const AnnotatedLine &Line,
   if (Left.isOneOf(tok::exclaim, tok::tilde))
     return false;
   if (Left.is(tok::at) &&
       Right.isOneOf(tok::identifier, tok::string_literal, tok::char_constant,
                     tok::numeric_constant, tok::l_paren, tok::l_brace,
                     tok::kw_true, tok::kw_false)) {
     return false;
   }
+
   if (Left.is(tok::colon))
     return !Left.is(TT_ObjCMethodExpr);
   if (Left.is(tok::coloncolon))
     return false;
   if (Left.is(tok::less) || Right.isOneOf(tok::greater, tok::less)) {
     if (Style.Language == FormatStyle::LK_TextProto ||
         (Style.Language == FormatStyle::LK_Proto &&
          (Left.is(TT_DictLiteral) || Right.is(TT_DictLiteral)))) {
if (Left.is(TT_PointerOrReference)) {
     // scope, e.g. lambda. We still need to special-case statements with
     // initializers.
     if (Line.IsMultiVariableDeclStmt &&
         (Left.NestingLevel == Line.First->NestingLevel ||
          ((Left.NestingLevel == Line.First->NestingLevel + 1) &&
           startsWithInitStatement(Line)))) {
       return false;
     }
+    if (Style.isCarbon() && Right.is(tok::r_square))
+      return false;
     return Left.Previous && !Left.Previous->isOneOf(
                                 tok::l_paren, tok::coloncolon, tok::l_square);
   }
   // Ensure right pointer alignment with ellipsis e.g. int *...P
   if (Left.is(tok::ellipsis) && Left.Previous &&
       Left.Previous->isOneOf(tok::star, tok::amp, tok::ampamp)) {
     return Style.PointerAlignment != FormatStyle::PAS_Right;
   }
if (Right.is(tok::l_paren)) {
     if (Left.is(TT_IfMacro)) {
       return Style.SpaceBeforeParensOptions.AfterIfMacros ||
              spaceRequiredBeforeParens(Right);
     }
     if (Line.Type == LT_ObjCDecl)
       return true;
     if (Left.is(tok::semi))
       return true;
+    if (Style.isCarbon()) {
+      if (Left.isOneOf(Keywords.kw_match, Keywords.kw_var)) {
+        return Style.SpaceBeforeParensOptions.AfterControlStatements ||
+               spaceRequiredBeforeParens(Right);
+      }
+    }
     if (Left.isOneOf(tok::pp_elif, tok::kw_for, tok::kw_while, tok::kw_switch,
                      tok::kw_case, TT_ForEachMacro, TT_ObjCForIn) ||
         Left.isIf(Line.Type != LT_PreprocessorDirective) ||
         Right.is(TT_ConditionLParen)) {
       return Style.SpaceBeforeParensOptions.AfterControlStatements ||
              spaceRequiredBeforeParens(Right);
     }
 
if (Style.isCpp()) {
     if (Left.isOneOf(tok::kw_public, tok::kw_private, tok::kw_protected,
                      tok::kw_virtual, tok::kw_extern, tok::kw_static,
                      Keywords.kw_internal, Keywords.kw_abstract,
                      Keywords.kw_sealed, Keywords.kw_override,
                      Keywords.kw_async, Keywords.kw_unsafe) &&
         Right.is(tok::l_paren)) {
       return true;
     }
+  } else if (Style.isCarbon()) {
+    if (Right.is(TT_JsTypeColon))
+      return false;
   } else if (Style.isJavaScript()) {
     if (Left.is(TT_FatArrow))
       return true;
     // for await ( ...
     if (Right.is(tok::l_paren) && Left.is(Keywords.kw_await) && Left.Previous &&
         Left.Previous->is(tok::kw_for)) {
       return true;
     }
if (Left.is(tok::r_paren) && canBeObjCSelectorComponent(Right)) {
       return false;
     }
   }
   if (Line.Type == LT_ObjCProperty &&
       (Right.is(tok::equal) || Left.is(tok::equal))) {
     return false;
   }
 
+  // (T:! Addable)
+  if (Style.isCarbon()) {
+    if (Left.is(tok::exclaim) && Left.Previous &&
+        Left.Previous->is(TT_JsTypeColon)) {
+      return true;
+    }
+    if (Right.is(tok::l_paren) && Left.Previous &&
+        Left.Previous->isOneOf(tok::kw_class, Keywords.kw_interface)) {
+      return false;
+    }
+  }
+
   if (Right.isOneOf(TT_TrailingReturnArrow, TT_LambdaArrow) ||
       Left.isOneOf(TT_TrailingReturnArrow, TT_LambdaArrow)) {
     return true;
   }
   if (Left.is(tok::comma) && !Right.is(TT_OverloadedOperatorLParen))
     return true;
   if (Right.is(tok::comma))
     return false;

clang/lib/Format/UnwrappedLineParser.cpp

case tok::identifier: {
       // a new unwrapped line, so they are special cased below.
       size_t TokenCount = Line->Tokens.size();
       if (Style.isJavaScript() && FormatTok->is(Keywords.kw_function) &&
           (TokenCount > 1 || (TokenCount == 1 && !Line->Tokens.front().Tok->is(
                                                      Keywords.kw_async)))) {
         tryToParseJSFunction();
         break;
       }
-      if ((Style.isJavaScript() || Style.Language == FormatStyle::LK_Java) &&
+      if ((Style.isJavaScript() || Style.Language == FormatStyle::LK_Java ||
+           Style.isCarbon()) &&
           FormatTok->is(Keywords.kw_interface)) {
         if (Style.isJavaScript()) {
           // In JavaScript/TypeScript, "interface" can be used as a standalone
           // identifier, e.g. in `var interface = 1;`. If "interface" is
           // followed by another identifier, it is very like to be an actual
           // interface declaration.
           unsigned StoredPosition = Tokens->getPosition();
           FormatToken *Next = Tokens->getNextToken();
bool UnwrappedLineParser::parseEnum() {
   // structural element afterwards. Thus, in "enum A {} n, m;",
   // "} n, m;" will end up in one unwrapped line.
 }
 
 bool UnwrappedLineParser::parseStructLike() {
   // parseRecord falls through and does not yet add an unwrapped line as a
   // record declaration or definition can start a structural element.
   parseRecord();
-  // This does not apply to Java, JavaScript and C#.
+  // This does not apply to Java, JavaScript and C# or Carbon
   if (Style.Language == FormatStyle::LK_Java || Style.isJavaScript() ||
-      Style.isCSharp()) {
+      Style.isCSharp() || Style.isCarbon()) {
     if (FormatTok->is(tok::semi))
       nextToken();
     addUnwrappedLine();
     return true;
   }
   return false;
 }
 
if (!IsNonMacroIdentifier) {
         parseParens();
       } else if (FormatTok->is(TT_AttributeSquare)) {
         parseSquare();
         // Consume the closing TT_AttributeSquare.
         if (FormatTok->Next && FormatTok->is(TT_AttributeSquare))
           nextToken();
       }
     }
+    if (Style.isCarbon()) {
+      if (FormatTok && FormatTok->is(tok::l_paren))
+        parseParens();
+    }
   }
 
   // Note that parsing away template declarations here leads to incorrectly
   // accepting function declarations as record declarations.
   // In general, we cannot solve this problem. Consider:
   // class A<int> B() {}
   // which can be a function definition or a class definition when B() is a
   // macro. If we find enough real-world cases where this is a problem, we

clang/tools/clang-format/ClangFormat.cpp

 int main(int argc, const char **argv) {
   llvm::InitLLVM X(argc, argv);
 
   cl::HideUnrelatedOptions(ClangFormatCategory);
 
   cl::SetVersionPrinter(PrintVersion);
   cl::ParseCommandLineOptions(
       argc, argv,
-      "A tool to format C/C++/Java/JavaScript/JSON/Objective-C/Protobuf/C# "
+      "A tool to format "
+      "C/C++/Java/JavaScript/JSON/Objective-C/Protobuf/C#/Carbon "
       "code.\n\n"
       "If no arguments are specified, it formats the code from standard input\n"
       "and writes the result to the standard output.\n"
       "If <file>s are given, it reformats the files. If -i is specified\n"
       "together with <file>s, the files are edited in-place. Otherwise, the\n"
       "result is written to the standard output.\n");
 
   if (Help) {

clang/tools/clang-format/clang-format-diff.py

parser.add_argument('-i', action='store_true', default=False,
                       help='apply edits to files instead of displaying a diff')
   parser.add_argument('-p', metavar='NUM', default=0,
                       help='strip the smallest prefix containing P slashes')
   parser.add_argument('-regex', metavar='PATTERN', default=None,
                       help='custom pattern selecting file paths to reformat '
                       '(case sensitive, overrides -iregex)')
   parser.add_argument('-iregex', metavar='PATTERN', default=
                       r'.*\.(cpp|cc|c\+\+|cxx|cppm|ccm|cxxm|c\+\+m|c|cl|h|hh|hpp|hxx'
-                      r'|m|mm|inc|js|ts|proto|protodevel|java|cs|json)',
+                      r'|m|mm|inc|js|ts|proto|protodevel|java|cs|json|carbon)',
                       help='custom pattern selecting file paths to reformat '
                       '(case insensitive, overridden by -regex)')
   parser.add_argument('-sort-includes', action='store_true', default=False,
                       help='let clang-format sort include blocks')
   parser.add_argument('-v', '--verbose', action='store_true',
                       help='be more verbose, ineffective without -i')
   parser.add_argument('-style',
                       help='formatting style to apply (LLVM, GNU, Google, Chromium, '

clang/tools/clang-format/git-clang-format

default_extensions = ','.join([
       'cu', 'cuh',  # CUDA
       # Other languages that clang-format supports
       'proto', 'protodevel',  # Protocol Buffers
       'java',  # Java
       'js',  # JavaScript
       'ts',  # TypeScript
       'cs',  # C Sharp
       'json',  # Json
+      'carbon',  # Carbon
       ])
 
   p = argparse.ArgumentParser(
     usage=usage, formatter_class=argparse.RawDescriptionHelpFormatter,
     description=desc)
   p.add_argument('--binary',
                  default=config.get('clangformat.binary', 'clang-format'),
                  help='path to clang-format'),

clang/unittests/Format/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   Support
   )
 
 add_clang_unittest(FormatTests
   CleanupTest.cpp
   DefinitionBlockSeparatorTest.cpp
   FormatTest.cpp
+  FormatTestCarbon.cpp
   FormatTestComments.cpp
   FormatTestCSharp.cpp
   FormatTestJS.cpp
   FormatTestJava.cpp
   FormatTestJson.cpp
   FormatTestObjC.cpp
   FormatTestProto.cpp
   FormatTestRawStrings.cpp

clang/unittests/Format/FormatTestCarbon.cpp

+//===- unittest/Format/FormatTestCarbon.cpp - Formatting tests for Carbon -===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "FormatTestUtils.h"
+#include "clang/Format/Format.h"
+#include "llvm/Support/Debug.h"
+#include "gtest/gtest.h"
+
+#define DEBUG_TYPE "format-test-json"
+
+namespace clang {
+namespace format {
+
+class FormatTestCarbon : public ::testing::Test {
+protected:
+  static std::string format(llvm::StringRef Code, unsigned Offset,
+                            unsigned Length, const FormatStyle &Style) {
+    LLVM_DEBUG(llvm::errs() << "---\n");
+    LLVM_DEBUG(llvm::errs() << Code << "\n\n");
+    std::vector<tooling::Range> Ranges(1, tooling::Range(Offset, Length));
+    tooling::Replacements Replaces = reformat(Style, Code, Ranges);
+    auto Result = applyAllReplacements(Code, Replaces);
+    EXPECT_TRUE(static_cast<bool>(Result));
+    LLVM_DEBUG(llvm::errs() << "\n" << *Result << "\n\n");
+    return *Result;
+  }
+
+  static std::string
+  format(llvm::StringRef Code,
+         const FormatStyle &Style = getGoogleStyle(FormatStyle::LK_Carbon)) {
+    return format(Code, 0, Code.size(), Style);
+  }
+
+  static FormatStyle getStyleWithColumns(unsigned ColumnLimit) {
+    FormatStyle Style = getGoogleStyle(FormatStyle::LK_Carbon);
+    Style.ColumnLimit = ColumnLimit;
+    return Style;
+  }
+
+  static void verifyFormatStable(llvm::StringRef Code,
+                                 const FormatStyle &Style) {
+    EXPECT_EQ(Code.str(), format(Code, Style)) << "Expected code is not stable";
+  }
+
+  static void verifyFormat(
+      llvm::StringRef Code,
+      const FormatStyle &Style = getGoogleStyle(FormatStyle::LK_Carbon)) {
+    verifyFormatStable(Code, Style);
+    EXPECT_EQ(Code.str(), format(test::messUp(Code), Style));
+  }
+};
+
+TEST_F(FormatTestCarbon, CarbonBasicFunctions) {
+  FormatStyle Style = getGoogleStyle(FormatStyle::LK_Carbon);
+  verifyFormat("fn Sum(var a: i32, var b: i32) -> i32 { return a + b; }",
+               Style);
+  verifyFormat("// Empty or void return type.\n"
+               "fn PrintCount(var count: i32) { Print(\" The count is { 0 } "
+               "\", count); }",
+               Style);
+}
+
+TEST_F(FormatTestCarbon, CarbonFunctionPrototype) {
+  FormatStyle Style = getGoogleStyle(FormatStyle::LK_Carbon);
+
+  verifyFormat("fn GetSetX[addr me: Point*](x: i32) -> i32 {", Style);
+  verifyFormat("fn Add[me: Self](k: i32) -> Self;", Style);
+  verifyFormat("fn Add[me: Self](k: i32) -> Self {", Style);
+  verifyFormat("fn Main() -> i32 {", Style);
+  verifyFormat("fn Make() -> (Self, T);", Style);
+  verifyFormat("fn Make() -> (Self, T) {", Style);
+  verifyFormat("fn F(n: i32, p: i32*, q: i32***) -> i32* {", Style);
+}
+
+TEST_F(FormatTestCarbon, CarbonVariable) {
+  FormatStyle Style = getGoogleStyle(FormatStyle::LK_Carbon);
+
+  verifyFormat("var name: auto = \"Carbon is an open-source programming\";",
+               Style);
+  verifyFormat("let id: i32 = 57;", Style);
+  verifyFormat("var total_articles_published: i32 = 4500;", Style);
+}
+
+TEST_F(FormatTestCarbon, CarbonVariableInLoop) {
+  FormatStyle Style = getGoogleStyle(FormatStyle::LK_Carbon);
+
+  verifyFormat("for (var name: String in names) {", Style);
+}
+
+TEST_F(FormatTestCarbon, CarbonVariableBreakAfterClass) {
+  FormatStyle Style = getGoogleStyle(FormatStyle::LK_Carbon);
+
+  verifyFormat("class Sum {\n"
+               "  var a: i32;\n"
+               "}\n"
+               "fn Main() -> i32 { var p1: Sum = {.a = 5}; }",
+               Style);
+}
+
+TEST_F(FormatTestCarbon, CarbonClassAndInterface) {
+  FormatStyle Style = getGoogleStyle(FormatStyle::LK_Carbon);
+
+  verifyFormat("class Class {\n"
+               "  var a: i32;\n"
+               "}",
+               Style);
+  verifyFormat("class GenericClass(T:! Type) {\n"
+               "  var a: T;\n"
+               "}",
+               Style);
+  verifyFormat("interface Interface {\n"
+               "  fn Make() -> Self;\n"
+               "}",
+               Style);
+  verifyFormat("interface GenericInterface(T:! Type) {\n"
+               "  fn Make() -> Self;\n"
+               "}",
+               Style);
+}
+
+TEST_F(FormatTestCarbon, CarbonMatch) {
+  FormatStyle Style = getGoogleStyle(FormatStyle::LK_Carbon);
+
+  verifyFormat("match (x) {", Style);
+}
+
+TEST_F(FormatTestCarbon, CarbonTuple) {
+  FormatStyle Style = getGoogleStyle(FormatStyle::LK_Carbon);
+
+  verifyFormat("var (x: auto, y: auto) = (2, 3);", Style);
+}
+
+} // namespace format
+} // end namespace clang

clang/unittests/Format/TokenAnnotatorTest.cpp

Tokens = Annotate("case (x)\n"
                     "    x;\n"
                     "endcase\n");
   ASSERT_EQ(Tokens.size(), 14u) << Tokens;
   EXPECT_TOKEN(Tokens[5], tok::question, TT_ConditionalExpr);
   EXPECT_TOKEN(Tokens[7], tok::colon, TT_ConditionalExpr);
   EXPECT_TOKEN(Tokens[9], tok::colon, TT_GotoLabelColon);
 }
 
+TEST_F(TokenAnnotatorTest, UnderstandsCarbonReturnType) {
+  FormatStyle Style = getGoogleStyle(FormatStyle::LK_Carbon);
+
+  auto Tokens = annotate("fn Sum(var a: i32, var b: i32) -> i32 {", Style);
+  ASSERT_EQ(Tokens.size(), 17u) << Tokens;
+  EXPECT_TOKEN(Tokens[13], tok::arrow, TT_TrailingReturnArrow);
+  EXPECT_TOKEN(Tokens[15], tok::l_brace, TT_FunctionLBrace);
+
+  Tokens = annotate("fn Add[me: Self](k: i32) -> Self {", Style);
+  ASSERT_EQ(Tokens.size(), 16u) << Tokens;
+  EXPECT_TOKEN(Tokens[12], tok::arrow, TT_TrailingReturnArrow);
+  EXPECT_TOKEN(Tokens[14], tok::l_brace, TT_FunctionLBrace);
+
+  Tokens = annotate("fn Add[me: Self](k: i32) -> Self;", Style);
+  ASSERT_EQ(Tokens.size(), 16u) << Tokens;
+  EXPECT_TOKEN(Tokens[12], tok::arrow, TT_TrailingReturnArrow);
+  EXPECT_TOKEN(Tokens[14], tok::semi, TT_Unknown);
+
+  Tokens = annotate("fn Add[me: Self](k: i32) -> i32*;", Style);
+  ASSERT_EQ(Tokens.size(), 17u) << Tokens;
+  EXPECT_TOKEN(Tokens[12], tok::arrow, TT_TrailingReturnArrow);
+  EXPECT_TOKEN(Tokens[15], tok::semi, TT_Unknown);
+}
+
+TEST_F(TokenAnnotatorTest, UnderstandsCarbonTypeOnColon) {
+  FormatStyle Style = getGoogleStyle(FormatStyle::LK_Carbon);
+
+  auto Tokens = annotate("let id: i32 = 57;", Style);
+  ASSERT_EQ(Tokens.size(), 8u) << Tokens;
+  EXPECT_TOKEN(Tokens[2], tok::colon, TT_JsTypeColon);
+
+  Tokens = annotate("var t2: {.x: i32, .y: i32} = {.x = 2, .y = 5};", Style);
+  ASSERT_EQ(Tokens.size(), 28u) << Tokens;
+  EXPECT_TOKEN(Tokens[6], tok::colon, TT_JsTypeColon);
+}
+
+TEST_F(TokenAnnotatorTest, UnderstandsCarbonPointerTypeOnColon) {
+  FormatStyle Style = getGoogleStyle(FormatStyle::LK_Carbon);
+  auto Tokens = annotate("fn GetSetX[addr me: Point*](x: i32) -> i32 {", Style);
+  ASSERT_EQ(Tokens.size(), 18u) << Tokens;
+  EXPECT_TOKEN(Tokens[5], tok::colon, TT_JsTypeColon);
+  EXPECT_TOKEN(Tokens[7], tok::star, TT_PointerOrReference);
+
+  Tokens = annotate(
+      "fn GetSetX[addr me: Point*, addr me: Point*](x: i32) -> i32 {", Style);
+  ASSERT_EQ(Tokens.size(), 24u) << Tokens;
+  EXPECT_TOKEN(Tokens[5], tok::colon, TT_JsTypeColon);
+  EXPECT_TOKEN(Tokens[7], tok::star, TT_PointerOrReference);
+  EXPECT_TOKEN(Tokens[11], tok::colon, TT_JsTypeColon);
+  EXPECT_TOKEN(Tokens[13], tok::star, TT_PointerOrReference);
+}
+
+TEST_F(TokenAnnotatorTest, UnderstandsCarbonTypeOnColonForLoop) {
+  FormatStyle Style = getGoogleStyle(FormatStyle::LK_Carbon);
+
+  auto Tokens = annotate("for (var name: String in names) {", Style);
+  ASSERT_EQ(Tokens.size(), 11u) << Tokens;
+  EXPECT_TOKEN(Tokens[4], tok::colon, TT_JsTypeColon);
+}
+
+TEST_F(TokenAnnotatorTest, UnderstandsCarbonTypeExclaim) {
+  FormatStyle Style = getGoogleStyle(FormatStyle::LK_Carbon);
+
+  auto Tokens = annotate("(T:! Addable)", Style);
+  ASSERT_EQ(Tokens.size(), 7u) << Tokens;
+  EXPECT_TOKEN(Tokens[2], tok::colon, TT_JsTypeColon);
+  EXPECT_TOKEN(Tokens[3], tok::exclaim, TT_UnaryOperator);
+  ASSERT_EQ(Tokens[3]->SpacesRequiredBefore, false);
+  EXPECT_TOKEN(Tokens[4], tok::identifier, TT_Unknown);
+  ASSERT_EQ(Tokens[4]->SpacesRequiredBefore, true);
+}
+
+TEST_F(TokenAnnotatorTest, UnderstandsCarbonClassTemplate) {
+  FormatStyle Style = getGoogleStyle(FormatStyle::LK_Carbon);
+
+  auto Tokens = annotate("class GenericClass(T:! Type) {", Style);
+  ASSERT_EQ(Tokens.size(), 10u) << Tokens;
+  EXPECT_TOKEN(Tokens[2], tok::l_paren, TT_Unknown);
+  ASSERT_EQ(Tokens[2]->SpacesRequiredBefore, false);
+  ASSERT_EQ(Tokens[2]->MustBreakBefore, false);
+}
+
+TEST_F(TokenAnnotatorTest, UnderstandsCarbonMatch) {
+  FormatStyle Style = getGoogleStyle(FormatStyle::LK_Carbon);
+
+  auto Tokens = annotate("match (x)", Style);
+  ASSERT_EQ(Tokens.size(), 5u) << Tokens;
+  EXPECT_TOKEN(Tokens[1], tok::l_paren, TT_Unknown);
+  ASSERT_EQ(Tokens[1]->SpacesRequiredBefore, true);
+}
+
 } // namespace
 } // namespace format
 } // namespace clang