Add rudimentary emission of compile-time-known default-initialized property values of specific conformances.

Author: artemcm

include/swift/AST/ConstTypeInfo.h

@@ -0,0 +1,131 @@
+//===--- ConstTypeInfo.h - Const Nominal Type Info Structure ----*- C++ -*-===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_AST_CONST_TYPE_INFO_H
+#define SWIFT_AST_CONST_TYPE_INFO_H
+
+#include <string>
+#include <vector>
+#include <memory>
+
+namespace swift {
+class NominalTypeDecl;
+class VarDecl;
+class Type;
+} // namespace swift
+
+/// Representation of a compile-time-known value, for example
+/// in a type property initializer expression
+class CompileTimeValue {
+public:
+  enum ValueKind { RawLiteral, InitCall, Builder, Dictionary, Runtime };
+
+  ValueKind getKind() const { return Kind; }
+
+protected:
+  CompileTimeValue(ValueKind ValueKind) : Kind(ValueKind) {}
+
+private:
+  ValueKind Kind;
+};
+
+/// A string representation of a raw literal value,
+/// for example an integer or string or float literal.
+class RawLiteralValue : public CompileTimeValue {
+public:
+  RawLiteralValue(std::string Value)
+      : CompileTimeValue(ValueKind::RawLiteral), Value(Value) {}
+
+  std::string getValue() const { return Value; }
+
+  static bool classof(const CompileTimeValue *T) {
+    return T->getKind() == ValueKind::RawLiteral;
+  }
+
+private:
+  std::string Value;
+};
+
+struct FunctionParameter {
+public:
+  std::string getLabel() { return Label; }
+  swift::Type *getType() { return Type; }
+
+private:
+  std::string Label;
+  swift::Type *Type;
+};
+
+/// A representation of a call to a type's initializer
+/// with a collection of (potentially compile-time-known) parameters
+class InitCallValue : public CompileTimeValue {
+public:
+  InitCallValue(std::string Name, std::vector<FunctionParameter> Parameters)
+      : CompileTimeValue(ValueKind::InitCall), Name(Name),
+        Parameters(Parameters) {}
+
+  static bool classof(const CompileTimeValue *T) {
+    return T->getKind() == ValueKind::InitCall;
+  }
+
+  std::string getName() const { return Name; }
+
+private:
+  std::string Name;
+  std::vector<FunctionParameter> Parameters;
+};
+
+/// A representation of a Builder pattern initialization expression
+class BuilderValue : public CompileTimeValue {
+public:
+  BuilderValue() : CompileTimeValue(ValueKind::Builder) {}
+
+  static bool classof(const CompileTimeValue *T) {
+    return T->getKind() == ValueKind::Builder;
+  }
+
+private:
+  std::vector<CompileTimeValue> Members;
+};
+
+/// A dictionary literal value representation
+class DictionaryValue : public CompileTimeValue {
+public:
+  DictionaryValue() : CompileTimeValue(ValueKind::Dictionary) {}
+
+  static bool classof(const CompileTimeValue *T) {
+    return T->getKind() == ValueKind::Dictionary;
+  }
+};
+
+/// A representation of an arbitrary value that does not fall under
+/// any of the above categories.
+class RuntimeValue : public CompileTimeValue {
+public:
+  RuntimeValue() : CompileTimeValue(ValueKind::Runtime) {}
+
+  static bool classof(const CompileTimeValue *T) {
+    return T->getKind() == ValueKind::Runtime;
+  }
+};
+
+struct ConstValueTypePropertyInfo {
+  swift::VarDecl *VarDecl;
+  std::shared_ptr<CompileTimeValue> Value;
+};
+
+struct ConstValueTypeInfo {
+  swift::NominalTypeDecl *TypeDecl;
+  std::vector<ConstValueTypePropertyInfo> Properties;
+};
+
+#endif

include/swift/AST/DiagnosticsFrontend.def

@@ -305,10 +305,18 @@ ERROR(batch_scan_input_file_missing,none,
       "cannot open batch dependencies scan input file from %0",
       (StringRef))
 
+ERROR(const_extract_protocol_list_input_file_missing,none,
+      "cannot open constant extraction protocol list input file from %0",
+      (StringRef))
+
 ERROR(batch_scan_input_file_corrupted,none,
       "batch dependencies scan input file from %0 is malformed",
       (StringRef))
 
+ERROR(const_extract_protocol_list_input_file_corrupted,none,
+      "constant extraction protocol list input file from %0 is malformed",
+      (StringRef))
+
 ERROR(unknown_platform_name, none,
       "unknown platform name %0", (StringRef))
 

include/swift/AST/TypeCheckRequests.h

@@ -18,6 +18,7 @@
 
 #include "swift/AST/ActorIsolation.h"
 #include "swift/AST/AnyFunctionRef.h"
+#include "swift/AST/ConstTypeInfo.h"
 #include "swift/AST/ASTNode.h"
 #include "swift/AST/ASTTypeIDs.h"
 #include "swift/AST/Effects.h"
@@ -693,6 +694,26 @@ class PropertyWrapperTypeInfoRequest
   bool isCached() const { return true; }
 };
 
+/// Retrieve information about compile-time-known
+class ConstantValueInfoRequest
+  : public SimpleRequest<ConstantValueInfoRequest,
+                         ConstValueTypeInfo(NominalTypeDecl *),
+                         RequestFlags::Cached> {
+public:
+  using SimpleRequest::SimpleRequest;
+
+private:
+  friend SimpleRequest;
+
+  // Evaluation.
+  ConstValueTypeInfo
+  evaluate(Evaluator &eval, NominalTypeDecl *nominal) const;
+
+public:
+  // Caching
+  bool isCached() const { return true; }
+};
+
 /// Request the nominal type declaration to which the given custom attribute
 /// refers.
 class AttachedPropertyWrappersRequest :

include/swift/AST/TypeCheckerTypeIDZone.def

@@ -260,6 +260,9 @@ SWIFT_REQUEST(TypeChecker, PropertyWrapperMutabilityRequest,
 SWIFT_REQUEST(TypeChecker, PropertyWrapperTypeInfoRequest,
               PropertyWrapperTypeInfo(NominalTypeDecl *), Cached,
               NoLocationInfo)
+SWIFT_REQUEST(TypeChecker, ConstantValueInfoRequest,
+              ConstValueTypeInfo(NominalTypeDecl *), Cached,
+              NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, ProtocolRequiresClassRequest, bool(ProtocolDecl *),
               SeparatelyCached, NoLocationInfo)
 SWIFT_REQUEST(TypeChecker, PrimaryAssociatedTypesRequest,

include/swift/ConstExtract/ConstExtract.h

@@ -0,0 +1,62 @@
+//===-------- ConstExtract.h -- Gather Compile-Time-Known Values ----------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef SWIFT_CONST_EXTRACT_H
+#define SWIFT_CONST_EXTRACT_H
+
+#include "swift/AST/ConstTypeInfo.h"
+#include "llvm/ADT/ArrayRef.h"
+#include <string>
+#include <unordered_set>
+#include <vector>
+
+namespace llvm {
+class StringRef;
+class raw_fd_ostream;
+}
+
+namespace swift {
+class SourceFile;
+class DiagnosticEngine;
+class ModuleDecl;
+} // namespace swift
+
+namespace swift {
+/// Parse a list of string identifiers from a file at the given path,
+/// representing names of protocols.
+bool
+parseProtocolListFromFile(llvm::StringRef protocolListFilePath,
+                          DiagnosticEngine &diags,
+                          std::unordered_set<std::string> &protocols);
+
+/// Gather compile-time-known values of properties in nominal type declarations
+/// in this file, of types which conform to one of the protocols listed in
+/// \c Protocols
+std::vector<ConstValueTypeInfo>
+gatherConstValuesForPrimary(const std::unordered_set<std::string> &Protocols,
+                            const SourceFile *File);
+
+/// Gather compile-time-known values of properties in nominal type declarations
+/// in this module, of types which conform to one of the protocols listed in
+/// \c Protocols
+std::vector<ConstValueTypeInfo>
+gatherConstValuesForModule(const std::unordered_set<std::string> &Protocols,
+                           ModuleDecl *Module);
+
+/// Serialize a collection of \c ConstValueInfos to JSON at the
+/// provided output stream.
+bool writeAsJSONToFile(const std::vector<ConstValueTypeInfo> &ConstValueInfos,
+                       llvm::raw_fd_ostream &OS);
+
+} // namespace swift
+
+#endif

lib/CMakeLists.txt

@@ -18,6 +18,7 @@ add_subdirectory(APIDigester)
 add_subdirectory(AST)
 add_subdirectory(ASTSectionImporter)
 add_subdirectory(Basic)
+add_subdirectory(ConstExtract)
 add_subdirectory(ClangImporter)
 add_subdirectory(Demangling)
 add_subdirectory(DependencyScan)

lib/ConstExtract/CMakeLists.txt

@@ -0,0 +1,8 @@
+add_swift_host_library(swiftConstExtract STATIC
+  ConstExtract.cpp
+  )
+target_link_libraries(swiftConstExtract PRIVATE
+  swiftClangImporter
+  swiftAST)
+
+set_swift_llvm_is_available(swiftConstExtract)