Merge remote-tracking branch 'origin/main' into simplify-blend

Author: fhahn

clang/include/clang/Basic/DiagnosticLexKinds.td

@@ -917,6 +917,8 @@ def warn_mmap_redundant_export_as : Warning<
   InGroup<PrivateModule>;
 def err_mmap_submodule_export_as : Error<
   "only top-level modules can be re-exported as public">;
+def err_mmap_qualified_export_as : Error<
+  "a module can only be re-exported as another top-level module">;
 
 def warn_quoted_include_in_framework_header : Warning<
   "double-quoted include \"%0\" in framework header, "

clang/include/clang/Basic/Module.h

@@ -100,6 +100,30 @@ struct ASTFileSignature : std::array<uint8_t, 20> {
   }
 };
 
+/// The set of attributes that can be attached to a module.
+struct ModuleAttributes {
+  /// Whether this is a system module.
+  LLVM_PREFERRED_TYPE(bool)
+  unsigned IsSystem : 1;
+
+  /// Whether this is an extern "C" module.
+  LLVM_PREFERRED_TYPE(bool)
+  unsigned IsExternC : 1;
+
+  /// Whether this is an exhaustive set of configuration macros.
+  LLVM_PREFERRED_TYPE(bool)
+  unsigned IsExhaustive : 1;
+
+  /// Whether files in this module can only include non-modular headers
+  /// and headers from used modules.
+  LLVM_PREFERRED_TYPE(bool)
+  unsigned NoUndeclaredIncludes : 1;
+
+  ModuleAttributes()
+      : IsSystem(false), IsExternC(false), IsExhaustive(false),
+        NoUndeclaredIncludes(false) {}
+};
+
 /// Required to construct a Module.
 ///
 /// This tag type is only constructible by ModuleMap, guaranteeing it ownership

clang/include/clang/CIR/Dialect/IR/CIROps.td

@@ -365,12 +365,6 @@ def FuncOp : CIR_Op<"func", [
        return getFunctionType().getReturnTypes();
     }
 
-    /// Hook for OpTrait::FunctionOpInterfaceTrait, called after verifying that
-    /// the 'type' attribute is present and checks if it holds a function type.
-    /// Ensures getType, getNumFuncArguments, and getNumFuncResults can be
-    /// called safely.
-    llvm::LogicalResult verifyType();
-
     //===------------------------------------------------------------------===//
     // SymbolOpInterface Methods
     //===------------------------------------------------------------------===//

clang/include/clang/CIR/Dialect/IR/CIRTypes.td

@@ -287,32 +287,44 @@ def CIR_BoolType :
 def CIR_FuncType : CIR_Type<"Func", "func"> {
   let summary = "CIR function type";
   let description = [{
-    The `!cir.func` is a function type. It consists of a single return type, a
-    list of parameter types and can optionally be variadic.
+    The `!cir.func` is a function type. It consists of an optional return type,
+    a list of parameter types and can optionally be variadic.
 
     Example:
 
     ```mlir
-    !cir.func<!bool ()>
-    !cir.func<!s32i (!s8i, !s8i)>
-    !cir.func<!s32i (!s32i, ...)>
+    !cir.func<()>
+    !cir.func<() -> bool>
+    !cir.func<(!s8i, !s8i)>
+    !cir.func<(!s8i, !s8i) -> !s32i>
+    !cir.func<(!s32i, ...) -> !s32i>
     ```
   }];
 
   let parameters = (ins ArrayRefParameter<"mlir::Type">:$inputs,
-                        "mlir::Type":$returnType, "bool":$varArg);
+                        OptionalParameter<"mlir::Type">:$optionalReturnType,
+                        "bool":$varArg);
+  // Use a custom parser to handle argument types with variadic elipsis.
   let assemblyFormat = [{
-    `<` $returnType ` ` `(` custom<FuncTypeArgs>($inputs, $varArg) `>`
+    `<` custom<FuncTypeParams>($inputs, $varArg)  (`->` $optionalReturnType^)? `>`
   }];
 
   let builders = [
+    // Create a FuncType, converting the return type from C-style to
+    // MLIR-style.  If the given return type is `cir::VoidType`, ignore it
+    // and create the FuncType with no return type, which is how MLIR
+    // represents function types.
     TypeBuilderWithInferredContext<(ins
       "llvm::ArrayRef<mlir::Type>":$inputs, "mlir::Type":$returnType,
       CArg<"bool", "false">:$isVarArg), [{
-      return $_get(returnType.getContext(), inputs, returnType, isVarArg);
+        return $_get(returnType.getContext(), inputs,
+                     mlir::isa<cir::VoidType>(returnType) ? nullptr : returnType,
+                     isVarArg);
     }]>
   ];
 
+  let genVerifyDecl = 1;
+
   let extraClassDeclaration = [{
     /// Returns whether the function is variadic.
     bool isVarArg() const { return getVarArg(); }
@@ -323,12 +335,17 @@ def CIR_FuncType : CIR_Type<"Func", "func"> {
     /// Returns the number of arguments to the function.
     unsigned getNumInputs() const { return getInputs().size(); }
 
-    /// Returns the result type of the function as an ArrayRef, enabling better
-    /// integration with generic MLIR utilities.
+    /// Get the C-style return type of the function, which is !cir.void if the
+    /// function returns nothing and the actual return type otherwise.
+    mlir::Type getReturnType() const;
+
+    /// Get the MLIR-style return type of the function, which is an empty
+    /// ArrayRef if the function returns nothing and a single-element ArrayRef
+    /// with the actual return type otherwise.
     llvm::ArrayRef<mlir::Type> getReturnTypes() const;
 
-    /// Returns whether the function is returns void.
-    bool isVoid() const;
+    /// Does the function type return nothing?
+    bool hasVoidReturn() const;
 
     /// Returns a clone of this function type with the given argument
     /// and result types.

clang/include/clang/Lex/ModuleMap.h

@@ -232,29 +232,7 @@ class ModuleMap {
 
   llvm::DenseMap<Module *, unsigned> ModuleScopeIDs;
 
-  /// The set of attributes that can be attached to a module.
-  struct Attributes {
-    /// Whether this is a system module.
-    LLVM_PREFERRED_TYPE(bool)
-    unsigned IsSystem : 1;
-
-    /// Whether this is an extern "C" module.
-    LLVM_PREFERRED_TYPE(bool)
-    unsigned IsExternC : 1;
-
-    /// Whether this is an exhaustive set of configuration macros.
-    LLVM_PREFERRED_TYPE(bool)
-    unsigned IsExhaustive : 1;
-
-    /// Whether files in this module can only include non-modular headers
-    /// and headers from used modules.
-    LLVM_PREFERRED_TYPE(bool)
-    unsigned NoUndeclaredIncludes : 1;
-
-    Attributes()
-        : IsSystem(false), IsExternC(false), IsExhaustive(false),
-          NoUndeclaredIncludes(false) {}
-  };
+  using Attributes = ModuleAttributes;
 
   /// A directory for which framework modules can be inferred.
   struct InferredDirectory {

clang/include/clang/Lex/ModuleMapFile.h

@@ -0,0 +1,162 @@
+//===- ModuleMapFile.h - Parsing and representation -------------*- C++ -*-===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_LEX_MODULEMAPFILE_H
+#define LLVM_CLANG_LEX_MODULEMAPFILE_H
+
+#include "clang/Basic/LLVM.h"
+// TODO: Consider moving ModuleId to another header, parsing a modulemap file is
+//   intended to not depend on anything about the clang::Module class.
+#include "clang/Basic/Module.h"
+#include "clang/Basic/SourceLocation.h"
+#include "llvm/ADT/StringRef.h"
+
+#include <optional>
+#include <variant>
+
+namespace clang {
+
+class DiagnosticsEngine;
+class SourceManager;
+
+namespace modulemap {
+
+struct ExportDecl;
+
+/// All declarations that can appear in a `module` declaration.
+using Decl =
+    std::variant<struct RequiresDecl, struct HeaderDecl, struct UmbrellaDirDecl,
+                 struct ModuleDecl, struct ExcludeDecl, struct ExportDecl,
+                 struct ExportAsDecl, struct ExternModuleDecl, struct UseDecl,
+                 struct LinkDecl, struct ConfigMacrosDecl, struct ConflictDecl>;
+
+struct RequiresFeature {
+  StringRef Feature;
+  SourceLocation Location;
+  bool RequiredState = true; /// False if preceded by '!'.
+};
+
+struct RequiresDecl {
+  SourceLocation Location;
+  std::vector<RequiresFeature> Features;
+};
+
+struct HeaderDecl {
+  StringRef Path;
+  SourceLocation Location;
+  SourceLocation PathLoc;
+  std::optional<int64_t> Size;
+  std::optional<int64_t> MTime;
+  LLVM_PREFERRED_TYPE(bool)
+  unsigned Private : 1;
+  LLVM_PREFERRED_TYPE(bool)
+  unsigned Textual : 1;
+  LLVM_PREFERRED_TYPE(bool)
+  unsigned Umbrella : 1;
+  LLVM_PREFERRED_TYPE(bool)
+  unsigned Excluded : 1;
+};
+
+struct UmbrellaDirDecl {
+  StringRef Path;
+  SourceLocation Location;
+};
+
+struct ModuleDecl {
+  ModuleId Id;
+  SourceLocation Location; /// Points to the first keyword in the decl.
+  ModuleAttributes Attrs;
+  std::vector<Decl> Decls;
+
+  LLVM_PREFERRED_TYPE(bool)
+  unsigned Explicit : 1;
+  LLVM_PREFERRED_TYPE(bool)
+  unsigned Framework : 1;
+};
+
+struct ExcludeDecl {
+  SourceLocation Location;
+  StringRef Module;
+};
+
+struct ExportDecl {
+  ModuleId Id;
+  SourceLocation Location;
+  bool Wildcard; /// True if the last element of the ModuleId is '*'.
+};
+
+struct ExportAsDecl {
+  SourceLocation Location;
+  ModuleId Id;
+};
+
+struct ExternModuleDecl {
+  SourceLocation Location;
+  ModuleId Id;
+  StringRef Path;
+};
+
+struct UseDecl {
+  SourceLocation Location;
+  ModuleId Id;
+};
+
+struct LinkDecl {
+  StringRef Library;
+  SourceLocation Location;
+  LLVM_PREFERRED_TYPE(bool)
+  unsigned Framework : 1;
+};
+
+struct ConfigMacrosDecl {
+  std::vector<StringRef> Macros;
+  SourceLocation Location;
+  LLVM_PREFERRED_TYPE(bool)
+  unsigned Exhaustive : 1;
+};
+
+struct ConflictDecl {
+  SourceLocation Location;
+  ModuleId Id;
+  StringRef Message;
+};
+
+using TopLevelDecl = std::variant<ModuleDecl, ExternModuleDecl>;
+
+/// Represents the parsed form of a module map file.
+///
+/// This holds many reference types (StringRef, SourceLocation, etc.) whose
+/// lifetimes are bound by the SourceManager and FileManager used.
+struct ModuleMapFile {
+  /// Beginning of the file, used for moduleMapFileRead callback.
+  SourceLocation Start;
+  std::vector<TopLevelDecl> Decls;
+
+  void dump(llvm::raw_ostream &out) const;
+};
+
+/// Parse a module map file into an in memory representation.
+///
+/// \param ID a valid local FileID.
+/// \param Dir the directory in which this module map was found.
+/// \param SM the SourceManager for \a ID.
+/// \param Diags where to send the diagnostics.
+/// \param IsSystem was this module map found in a system search path.
+/// \param Offset optional offset into the buffer associated with \a ID. This is
+///               used for handling `#pragma clang module build`. Set to the end
+///               of the module map on return.
+///
+/// \returns The parsed ModuleMapFile if successful, std::nullopt otherwise.
+std::optional<ModuleMapFile>
+parseModuleMap(FileID ID, clang::DirectoryEntryRef Dir, SourceManager &SM,
+               DiagnosticsEngine &Diags, bool IsSystem, unsigned *Offset);
+
+} // namespace modulemap
+} // namespace clang
+
+#endif

clang/include/clang/Tooling/DependencyScanning/ModuleDepCollector.h

@@ -317,7 +317,7 @@ class ModuleDepCollector final : public DependencyCollector {
 
   /// Compute the context hash for \p Deps, and create the mapping
   /// \c ModuleDepsByID[Deps.ID] = &Deps.
-  void associateWithContextHash(const CowCompilerInvocation &CI,
+  void associateWithContextHash(const CowCompilerInvocation &CI, bool IgnoreCWD,
                                 ModuleDeps &Deps);
 };
 

clang/lib/CIR/CodeGen/CIRGenTypes.cpp

@@ -60,7 +60,7 @@ bool CIRGenTypes::isFuncTypeConvertible(const FunctionType *ft) {
 mlir::Type CIRGenTypes::convertFunctionTypeInternal(QualType qft) {
   assert(qft.isCanonical());
   const FunctionType *ft = cast<FunctionType>(qft.getTypePtr());
-  // First, check whether we can build the full fucntion type. If the function
+  // First, check whether we can build the full function type. If the function
   // type depends on an incomplete type (e.g. a struct or enum), we cannot lower
   // the function type.
   if (!isFuncTypeConvertible(ft)) {

clang/lib/CIR/Dialect/IR/CIRDialect.cpp

@@ -416,17 +416,6 @@ void cir::FuncOp::print(OpAsmPrinter &p) {
   }
 }
 
-// Hook for OpTrait::FunctionLike, called after verifying that the 'type'
-// attribute is present.  This can check for preconditions of the
-// getNumArguments hook not failing.
-LogicalResult cir::FuncOp::verifyType() {
-  auto type = getFunctionType();
-  if (!isa<cir::FuncType>(type))
-    return emitOpError("requires '" + getFunctionTypeAttrName().str() +
-                       "' attribute of function type");
-  return success();
-}
-
 // TODO(CIR): The properties of functions that require verification haven't
 // been implemented yet.
 mlir::LogicalResult cir::FuncOp::verify() { return success(); }