Improve codegen, Start on constification.

There are also various experiements that need cleaning up,
specifically around builtins and source location.

Author: EricWF

clang/include/clang/AST/ASTContext.h

@@ -360,6 +360,10 @@ class ASTContext : public RefCountedBase<ASTContext> {
   /// __builtin_va_list type.
   mutable TypedefDecl *BuiltinVaListDecl = nullptr;
 
+  /// The typedef for the predefined __builtin_source_loc_impl_type
+  /// type.
+  mutable TypedefDecl *BuiltinSourceLocImplDecl = nullptr;
+
   /// The typedef for the predefined \c __builtin_ms_va_list type.
   mutable TypedefDecl *BuiltinMSVaListDecl = nullptr;
 
@@ -1173,6 +1177,9 @@ class ASTContext : public RefCountedBase<ASTContext> {
   // The decl is built when constructing 'BuiltinVaListDecl'.
   mutable Decl *VaListTagDecl = nullptr;
 
+  // The implicit record decl __builtin_source_loc_impl_type
+  mutable Decl *BuiltinSourceLocImplRecordDecl = nullptr;
+
   // Implicitly-declared type 'struct _GUID'.
   mutable TagDecl *MSGuidTagDecl = nullptr;
 
@@ -2181,6 +2188,20 @@ class ASTContext : public RefCountedBase<ASTContext> {
     return getTagDeclType(MSGuidTagDecl);
   }
 
+  /// Retrieve the C type declaration corresponding to the predefined
+  /// \c __builtin_source_loc_impl_t type.
+  TypedefDecl *getBuiltinSourceLocImplDecl() const;
+
+  /// Retrieve the type of the \c __builtin_source_loc_impl_t type.
+  QualType getBuiltinSourceLocImplType() const {
+    return getTypeDeclType(getBuiltinSourceLocImplDecl());
+  }
+
+  /// Retrieve the C type declaration corresponding to the predefined
+  /// \c __builtin_source_loc_t type.
+  // FIXME(ERICWF): Is this needed
+  Decl *getBuiltinSourceLocImplRecord() const;
+
   /// Return whether a declaration to a builtin is allowed to be
   /// overloaded/redeclared.
   bool canBuiltinBeRedeclared(const FunctionDecl *) const;

clang/include/clang/AST/DeclCXX.h

@@ -4399,12 +4399,15 @@ const StreamingDiagnostic &operator<<(const StreamingDiagnostic &DB,
                                       AccessSpecifier AS);
 
 
+class MaterializedResultNameDecl;
+
 /// A result name introduces in a post condition. For instance, given:
 ///
 ///   int foo() post(r : r > 0);
 ///
 /// Where `r` refers to the value returned by the function
 class ResultNameDecl : public ValueDecl {
+  MaterializedResultNameDecl *MaterializedDecl = nullptr;
 
   ResultNameDecl(DeclContext *DC, SourceLocation IdLoc, IdentifierInfo *Id, QualType T)
       : ValueDecl(Decl::ResultName, DC, IdLoc, Id, T) {}
@@ -4422,10 +4425,59 @@ class ResultNameDecl : public ValueDecl {
   using ValueDecl::getDeclName;
   using ValueDecl::setType;
 
+  void setMaterializedResultNameDecl(MaterializedResultNameDecl *D) {
+
+  }
+
   static bool classof(const Decl *D) { return classofKind(D->getKind()); }
   static bool classofKind(Kind K) { return K == Decl::ResultName; }
 };
 
+/*
+class MaterializedResultNameDecl final
+    : public VarDecl,
+      private llvm::TrailingObjects<MaterializedResultNameDecl, ResultNameDecl *> {
+  /// The number of BindingDecl*s following this object.
+  unsigned NumBindings;
+
+  MaterializedResultNameDecl(ASTContext &C, DeclContext *DC, SourceLocation StartLoc,
+                    SourceLocation LSquareLoc, QualType T,
+                    TypeSourceInfo *TInfo, StorageClass SC,
+                    ArrayRef<ResultNameDecl *> Bindings)
+      : VarDecl(Decomposition, C, DC, StartLoc, LSquareLoc, nullptr, T, TInfo,
+                SC),
+        NumBindings(Bindings.size()) {
+    std::uninitialized_copy(Bindings.begin(), Bindings.end(),
+                            getTrailingObjects<ResultNameDecl *>());
+    for (auto *B : Bindings)
+      B->setDecomposedDecl(this);
+  }
+
+  void anchor() override;
+
+public:
+  friend class ASTDeclReader;
+  friend TrailingObjects;
+
+  static MaterializedResultNameDecl *Create(ASTContext &C, DeclContext *DC,
+                                   SourceLocation StartLoc,
+                                   SourceLocation LSquareLoc,
+                                   QualType T, TypeSourceInfo *TInfo,
+                                   StorageClass S,
+                                   ArrayRef<BindingDecl *> Bindings);
+  static MaterializedResultNameDecl *CreateDeserialized(ASTContext &C, GlobalDeclID ID,
+                                               unsigned NumBindings);
+
+  ArrayRef<BindingDecl *> bindings() const {
+    return llvm::ArrayRef(getTrailingObjects<BindingDecl *>(), NumBindings);
+  }
+
+  void printName(raw_ostream &OS, const PrintingPolicy &Policy) const override;
+
+  static bool classof(const Decl *D) { return classofKind(D->getKind()); }
+  static bool classofKind(Kind K) { return K == Decomposition; }
+};
+*/
 } // namespace clang
 
 #endif // LLVM_CLANG_AST_DECLCXX_H

clang/include/clang/AST/DeclID.h

@@ -84,13 +84,16 @@ enum PredefinedDeclIDs {
 
   /// The internal '__type_pack_element' template.
   PREDEF_DECL_TYPE_PACK_ELEMENT_ID = 17,
+
+  /// The internal '__builtin_source_location_impl_type' typedef.
+  PREDEF_DECL_BUILTIN_SOURCE_LOCATION_IMPL_T_ID = 18,
 };
 
 /// The number of declaration IDs that are predefined.
 ///
 /// For more information about predefined declarations, see the
 /// \c PredefinedDeclIDs type and the PREDEF_DECL_*_ID constants.
-const unsigned int NUM_PREDEF_DECL_IDS = 18;
+const unsigned int NUM_PREDEF_DECL_IDS = 19;
 
 /// GlobalDeclID means DeclID in the current ASTContext and LocalDeclID means
 /// DeclID specific to a certain ModuleFile. Specially, in ASTWriter, the

clang/include/clang/AST/Expr.h

@@ -4723,12 +4723,13 @@ enum class SourceLocIdentKind {
   FileName,
   Line,
   Column,
-  SourceLocStruct
+  SourceLocStruct,
+  BuiltinSourceLocStruct
 };
 
 /// Represents a function call to one of __builtin_LINE(), __builtin_COLUMN(),
 /// __builtin_FUNCTION(), __builtin_FUNCSIG(), __builtin_FILE(),
-/// __builtin_FILE_NAME() or __builtin_source_location().
+/// __builtin_FILE_NAME(), __builtin_source_location(), or __builtin_source_location()2.
 class SourceLocExpr final : public Expr {
   SourceLocation BuiltinLoc, RParenLoc;
   DeclContext *ParentContext;
@@ -4760,6 +4761,7 @@ class SourceLocExpr final : public Expr {
     case SourceLocIdentKind::Function:
     case SourceLocIdentKind::FuncSig:
     case SourceLocIdentKind::SourceLocStruct:
+    case SourceLocIdentKind::BuiltinSourceLocStruct:
       return false;
     case SourceLocIdentKind::Line:
     case SourceLocIdentKind::Column:
@@ -4794,6 +4796,7 @@ class SourceLocExpr final : public Expr {
     case SourceLocIdentKind::Function:
     case SourceLocIdentKind::FuncSig:
     case SourceLocIdentKind::SourceLocStruct:
+    case SourceLocIdentKind::BuiltinSourceLocStruct:
       return true;
     default:
       return false;

clang/include/clang/AST/Stmt.h

@@ -709,7 +709,7 @@ class alignas(void *) Stmt {
     /// The kind of source location builtin represented by the SourceLocExpr.
     /// Ex. __builtin_LINE, __builtin_FUNCTION, etc.
     LLVM_PREFERRED_TYPE(SourceLocIdentKind)
-    unsigned Kind : 3;
+    unsigned Kind : 4;
   };
 
   class StmtExprBitfields {

clang/include/clang/Basic/Builtins.td

@@ -2624,6 +2624,17 @@ def ContractViolation : Builtin {
   let Attributes = [NoThrow, NoReturn, Constexpr];
 }
 
+def UnnamedConstant : Builtin {
+  let Spellings = ["__builtin_unnamed_constant"];
+  let Prototype = "void(...)";
+  let Attributes = [NoThrow, CustomTypeChecking, Constexpr];
+}
+
+def CurrentContractEvaluationSemantic : Builtin {
+  let Spellings = ["__builtin_contract_evaluation_semantic"];
+  let Prototype = "int()";
+  let Attributes = [NoThrow, Constexpr];
+}
 
 // C99 library functions
 // C99 stdarg.h

clang/include/clang/Basic/DiagnosticSemaKinds.td

@@ -11879,6 +11879,9 @@ def err_coroutine_return_type : Error<
 >;
 } // end of coroutines issue category
 
+def select_contract_kind : TextSubstitution<
+  "%select{pre|post|contract_assert}0">;
+
 let CategoryName = "Contract Issue" in {
 def err_ericwf_unimplemented : Error<
   "contract feature %0 is not yet implemented (complain to [email protected])"
@@ -11899,6 +11902,8 @@ def err_void_result_name : Error<
   "result name %0 cannot be used with a void return type">;
 def err_deduced_auto_result_name_without_body : Error<
   "result name on function with deduced return type requires a body">;
+def err_result_name_not_allowed : Error<
+  "result name %0 not allowed outside of post condition specifier">;
 
 } // end of contracts issues
 let CategoryName = "Documentation Issue" in {

clang/include/clang/Basic/LangOptions.h

@@ -443,35 +443,29 @@ class LangOptionsBase {
 
   /// Contract evaluation mode. Determines whether to check contracts, and 
   // whether contract failures cause compile errors.
-  enum class ContractEvalMode {
+  enum class ContractEvaluationSemantic {
     // Contracts are parsed, syntax checked and type checked, but never evaluated.
+    // FIXME(EricWF): This doesn't yet map to an actual enumerator in
+    //  std::contracts::evaluation_semantic
     Ignore = 0,
 
-    // Contracts are run, and failures are reported, but contract failures do not
-    // logically stop execution of the program, nor can the compiler assume 
-    // contracts are true for optimizing.
-    Observe = 1,
-
     // Contracts are run, failures are reported, and when a contract fails the 
     // program is terminated. The compiler can assume after contracts statements 
     // that the contracts hold.
-    Enforce = 2,
-  };
+    Enforce = 1,
 
-  /// Determines the strategy to implement contract evaluation
-  enum class ContractImplStrategy {
-    // Contracts are checked after entering and before exiting a function.
-    Callee = 0,
-    
-    // Precontracts are checked before making a function call and after entering the function
-    // Postcontracts are checked before returning from a function, and after returning from a function call.
-    Both = 1,
-
-    // Precontracts are checked before making a function call, postcontracts 
-    // are checked before returning from a function call.
-    Split = 2,
+    // Contracts are run, and failures are reported, but contract failures do not
+    // logically stop execution of the program, nor can the compiler assume
+    // contracts are true for optimizing.
+    Observe = 2,
+
+    // Contracts are run, failures cause an immediate trap
+    // FIXME(EricWF): This doesn't yet map to an actual enumerator in
+    //  std::contracts::evaluation_semantic
+    QuickEnforce = 3,
   };
 
+
   // Define simple language options (with no accessors).
 #define LANGOPT(Name, Bits, Default, Description) unsigned Name : Bits;
 #define ENUM_LANGOPT(Name, Type, Bits, Default, Description)
@@ -587,10 +581,11 @@ class LangOptions : public LangOptionsBase {
   GPUDefaultStreamKind GPUDefaultStream;
 
   /// C++ contracts evaluation mode
-  ContractEvalMode ContractEvaluation;
+  ContractEvaluationSemantic ContractEvalSemantic;
 
-  /// C++ contracts implementation strategy
-  ContractImplStrategy ContractStrategy;
+  /// A List of + or - prefixed contract groups to enable or disable
+  /// FIXME(EricWF): Implement this
+  std::vector<std::string> ClangContractGroups;
 
   /// The seed used by the randomize structure layout feature.
   std::string RandstructSeed;

clang/include/clang/Basic/TokenKinds.def

@@ -458,6 +458,8 @@ KEYWORD(__builtin_FUNCSIG           , KEYMS)
 KEYWORD(__builtin_LINE              , KEYALL)
 KEYWORD(__builtin_COLUMN            , KEYALL)
 KEYWORD(__builtin_source_location   , KEYCXX)
+KEYWORD(__builtin_source_location2  , KEYCXX)
+
 
 // __builtin_types_compatible_p is a GNU C extension that we handle like a C++
 // type trait.

clang/include/clang/Driver/Options.td

@@ -1668,27 +1668,27 @@ def offload_EQ : CommaJoined<["--"], "offload=">, Flags<[NoXarchOption]>,
   HelpText<"Specify comma-separated list of offloading target triples (CUDA and HIP only)">;
 
 // C++ Contracts
-defm fcontracts : BoolFOption<"contracts",
+defm contracts : BoolFOption<"contracts",
   LangOpts<"Contracts">, DefaultFalse,
-  PosFlag<SetTrue, [], [ClangOption, CC1Option],
+  PosFlag<SetTrue, [], [ClangOption, CC1Option, CLOption],
           "Enable support for C++ Contracts">,
   NegFlag<SetFalse>>;
 
-def fcontracts_eval_mode : Joined<["-"], "fcontracts_evaluation=">,
-  HelpText<"Specify contract evaluation mode. The default value is 'ignore'.">,
-  Values<"0,1,2">,
+
+def fcontract_evaluation_semantic_EQ : Joined<["-"], "fcontract-evaluation-semantic=">,
+  HelpText<"Specify contract evaluation semantic. The default value is 'enforce'.">,
+  Values<"ignore,enforce,observe,quick_enforce">,
   Visibility<[ClangOption, CC1Option]>,
-  NormalizedValuesScope<"LangOptions::ContractEvalMode">,
-  NormalizedValues<["Ignore", "Observe", "Enforce"]>,
-  MarshallingInfoEnum<LangOpts<"ContractEvaluation">, "Ignore">;
+  NormalizedValuesScope<"LangOptions::ContractEvaluationSemantic">,
+  NormalizedValues<["Ignore", "Enforce", "Observe", "QuickEnforce"]>,
+  MarshallingInfoEnum<LangOpts<"ContractEvalSemantic">, "Enforce">;
 
-def fcontracts_impl_strategy : Joined<["-"], "fcontracts_strategy=">,
-  HelpText<"Specify contract implementation strategy. The default value is 'callee'.">,
-  Values<"0,1,2">,
+def fclang_contract_groups_EQ : CommaJoined<["-"], "fcontract-groups=">,
   Visibility<[ClangOption, CC1Option]>,
-  NormalizedValuesScope<"LangOptions::ContractImplStrategy">,
-  NormalizedValues<["Callee", "Both", "Split"]>,
-  MarshallingInfoEnum<LangOpts<"ContractStrategy">, "Callee">;
+  HelpText<"Clang extension. Enable or disable contracts by group. The argument is a comma-separated "
+           "sequence of one or more group names, each prefixed by '+' or '-'.">,
+  MarshallingInfoStringVector<LangOpts<"ClangContractGroups">>;
+
 
 // C++ Coroutines
 defm coroutines : BoolFOption<"coroutines",