embedded: support default methods in existentials and improve embedded error reporting

SwiftCompilerSources/Sources/AST/CMakeLists.txt

@@ -12,6 +12,7 @@ add_swift_compiler_module(AST
   SOURCES
     Declarations.swift
     Conformance.swift
+    DiagnosticEngine.swift
     GenericSignature.swift
     Registration.swift
     SubstitutionMap.swift

SwiftCompilerSources/Sources/AST/Conformance.swift

@@ -17,7 +17,7 @@ import ASTBridging
 /// members to the type (or extension) members that provide the functionality for the concrete type.
 ///
 ///  TODO: Ideally, `Conformance` should be an enum
-public struct Conformance: CustomStringConvertible, NoReflectionChildren {
+public struct Conformance: CustomStringConvertible, Hashable, NoReflectionChildren {
   public let bridged: BridgedConformance
 
   public init(bridged: BridgedConformance) {
@@ -28,6 +28,14 @@ public struct Conformance: CustomStringConvertible, NoReflectionChildren {
     return String(taking: bridged.getDebugDescription())
   }
 
+  public func hash(into hasher: inout Hasher) {
+    hasher.combine(bridged.opaqueValue)
+  }
+
+  public static func ==(lhs: Conformance, rhs: Conformance) -> Bool {
+    lhs.bridged.opaqueValue == rhs.bridged.opaqueValue
+  }
+
   public var isConcrete: Bool { bridged.isConcrete() }
 
   public var isValid: Bool { bridged.isValid() }
@@ -37,7 +45,7 @@ public struct Conformance: CustomStringConvertible, NoReflectionChildren {
     return Type(bridged: bridged.getType())
   }
 
-  public var proto: ProtocolDecl {
+  public var `protocol`: ProtocolDecl {
     return bridged.getRequirement().getAs(ProtocolDecl.self)
   }
   public var isSpecialized: Bool {

SwiftCompilerSources/Sources/AST/Declarations.swift

@@ -23,6 +23,9 @@ public class Decl: CustomStringConvertible, Hashable {
   /// The module in which this declaration resides.
   public var parentModule: ModuleDecl { bridged.getModuleContext().getAs(ModuleDecl.self) }
 
+  /// The parent DeclContext if it is a Decl.
+  public var parent: Decl? { bridged.getParent().decl }
+
   // True if this declaration is imported from C/C++/ObjC.
   public var hasClangNode: Bool { bridged.hasClangNode() }
 
@@ -69,7 +72,9 @@ final public class ClassDecl: NominalTypeDecl {
   }
 }
 
-final public class ProtocolDecl: NominalTypeDecl {}
+final public class ProtocolDecl: NominalTypeDecl {
+  public var requiresClass: Bool { bridged.ProtocolDecl_requiresClass() }
+}
 
 final public class BuiltinTupleDecl: NominalTypeDecl {}
 

SwiftCompilerSources/Sources/Optimizer/Utilities/DiagnosticEngine.swift → SwiftCompilerSources/Sources/AST/DiagnosticEngine.swift

@@ -13,40 +13,34 @@
 import ASTBridging
 
 import Basic
-import SIL
 
-typealias DiagID = BridgedDiagID
+public typealias DiagID = BridgedDiagID
 
-protocol DiagnosticArgument {
+public protocol DiagnosticArgument {
   func _withBridgedDiagnosticArgument(_ fn: (BridgedDiagnosticArgument) -> Void)
 }
 extension String: DiagnosticArgument {
-  func _withBridgedDiagnosticArgument(_ fn: (BridgedDiagnosticArgument) -> Void) {
+  public func _withBridgedDiagnosticArgument(_ fn: (BridgedDiagnosticArgument) -> Void) {
     _withBridgedStringRef { fn(BridgedDiagnosticArgument($0)) }
   }
 }
 extension StringRef: DiagnosticArgument {
-  func _withBridgedDiagnosticArgument(_ fn: (BridgedDiagnosticArgument) -> Void) {
+  public func _withBridgedDiagnosticArgument(_ fn: (BridgedDiagnosticArgument) -> Void) {
     fn(BridgedDiagnosticArgument(_bridged))
   }
 }
 extension Int: DiagnosticArgument {
-  func _withBridgedDiagnosticArgument(_ fn: (BridgedDiagnosticArgument) -> Void) {
+  public func _withBridgedDiagnosticArgument(_ fn: (BridgedDiagnosticArgument) -> Void) {
     fn(BridgedDiagnosticArgument(self))
   }
 }
 extension Type: DiagnosticArgument {
-  func _withBridgedDiagnosticArgument(_ fn: (BridgedDiagnosticArgument) -> Void) {
-    fn(bridged.asDiagnosticArgument())
-  }
-}
-extension DeclRef: DiagnosticArgument {
-  func _withBridgedDiagnosticArgument(_ fn: (BridgedDiagnosticArgument) -> Void) {
+  public func _withBridgedDiagnosticArgument(_ fn: (BridgedDiagnosticArgument) -> Void) {
     fn(bridged.asDiagnosticArgument())
   }
 }
 
-struct DiagnosticFixIt {
+public struct DiagnosticFixIt {
   let start: SourceLoc
   let byteLength: Int
   let text: String
@@ -67,10 +61,10 @@ struct DiagnosticFixIt {
   }
 }
 
-struct DiagnosticEngine {
+public struct DiagnosticEngine {
   private let bridged: BridgedDiagnosticEngine
 
-  init(bridged: BridgedDiagnosticEngine) {
+  public init(bridged: BridgedDiagnosticEngine) {
     self.bridged = bridged
   }
   init?(bridged: BridgedNullableDiagnosticEngine) {
@@ -80,9 +74,9 @@ struct DiagnosticEngine {
     self.bridged = BridgedDiagnosticEngine(raw: raw)
   }
 
-  func diagnose(_ position: SourceLoc?,
-                       _ id: DiagID,
+  public func diagnose(_ id: DiagID,
                        _ args: [DiagnosticArgument],
+                       at position: SourceLoc?,
                        highlight: CharSourceRange? = nil,
                        fixIts: [DiagnosticFixIt] = []) {
 
@@ -136,11 +130,32 @@ struct DiagnosticEngine {
     closure()
   }
 
-  func diagnose(_ position: SourceLoc?,
-                       _ id: DiagID,
+  public func diagnose(_ id: DiagID,
                        _ args: DiagnosticArgument...,
+                       at position: SourceLoc?,
                        highlight: CharSourceRange? = nil,
                        fixIts: DiagnosticFixIt...) {
-    diagnose(position, id, args, highlight: highlight, fixIts: fixIts)
+    diagnose(id, args, at: position, highlight: highlight, fixIts: fixIts)
+  }
+
+  public func diagnose(_ diagnostic: Diagnostic) {
+    diagnose(diagnostic.id, diagnostic.arguments, at: diagnostic.position)
+  }
+}
+
+/// A utility struct which allows throwing a Diagnostic.
+public struct Diagnostic : Error {
+  public let id: DiagID
+  public let arguments: [DiagnosticArgument]
+  public let position: SourceLoc?
+
+  public init(_ id: DiagID, _ arguments: DiagnosticArgument..., at position: SourceLoc?) {
+    self.init(id, arguments, at: position)
+  }
+
+  public init(_ id: DiagID, _ arguments: [DiagnosticArgument], at position: SourceLoc?) {
+    self.id = id
+    self.arguments = arguments
+    self.position = position
   }
 }

SwiftCompilerSources/Sources/AST/GenericSignature.swift

@@ -29,4 +29,8 @@ public struct GenericSignature: CustomStringConvertible, NoReflectionChildren {
   public var genericParameters: TypeArray {
     TypeArray(bridged: bridged.getGenericParams())
   }
+
+  public func mapTypeIntoContext(_ type: Type) -> Type {
+    Type(bridged: bridged.mapTypeIntoContext(type.bridged))
+  }
 }

SwiftCompilerSources/Sources/AST/Type.swift

@@ -48,6 +48,8 @@ public struct Type: TypeProperties, CustomStringConvertible, NoReflectionChildre
 
   public var instanceTypeOfMetatype: Type { Type(bridged: bridged.getInstanceTypeOfMetatype()) }
 
+  public var staticTypeOfDynamicSelf: Type { Type(bridged: bridged.getStaticTypeOfDynamicSelf()) }
+
   public var superClassType: Type? {
     precondition(isClass)
     let bridgedSuperClassTy = bridged.getSuperClassType()
@@ -136,10 +138,12 @@ extension TypeProperties {
 
   public var isTuple: Bool { rawType.bridged.isTuple() }
   public var isFunction: Bool { rawType.bridged.isFunction() }
+  public var isArchetype: Bool { rawType.bridged.isArchetype() }
   public var isExistentialArchetype: Bool { rawType.bridged.isExistentialArchetype() }
   public var isExistentialArchetypeWithError: Bool { rawType.bridged.isExistentialArchetypeWithError() }
   public var isExistential: Bool { rawType.bridged.isExistential() }
   public var isClassExistential: Bool { rawType.bridged.isClassExistential() }
+  public var isGenericTypeParameter: Bool { rawType.bridged.isGenericTypeParam() }
   public var isUnownedStorageType: Bool { return rawType.bridged.isUnownedStorageType() }
   public var isMetatype: Bool { rawType.bridged.isMetatypeType() }
   public var isExistentialMetatype: Bool { rawType.bridged.isExistentialMetatypeType() }
@@ -186,6 +190,7 @@ extension TypeProperties {
   public var hasLocalArchetype: Bool { rawType.bridged.hasLocalArchetype() }
   public var isEscapable: Bool { rawType.bridged.isEscapable() }
   public var isNoEscape: Bool { rawType.bridged.isNoEscape() }
+  public var archetypeRequiresClass: Bool { rawType.bridged.archetypeRequiresClass() }
 
   public var representationOfMetatype: AST.`Type`.MetatypeRepresentation {
     rawType.bridged.getRepresentationOfMetatype().representation

SwiftCompilerSources/Sources/Basic/Utils.swift

@@ -96,6 +96,16 @@ public struct StringRef : CustomStringConvertible, NoReflectionChildren {
     return buffer[index]
   }
 
+  public func startsWith(_ prefix: StaticString) -> Bool {
+    return prefix.withUTF8Buffer { (prefixBuffer: UnsafeBufferPointer<UInt8>) in
+      if count < prefixBuffer.count {
+        return false
+      }
+      let buffer = UnsafeBufferPointer<UInt8>(start: _bridged.data, count: prefixBuffer.count)
+      return buffer.elementsEqual(prefixBuffer, by: ==)
+    }
+  }
+
   public static func ==(lhs: StringRef, rhs: StringRef) -> Bool {
     let lhsBuffer = UnsafeBufferPointer<UInt8>(start: lhs._bridged.data, count: lhs.count)
     let rhsBuffer = UnsafeBufferPointer<UInt8>(start: rhs._bridged.data, count: rhs.count)

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/DiagnoseInfiniteRecursion.swift

@@ -289,7 +289,7 @@ private struct Analysis {
     worklist.pushIfNotVisited(function.entryBlock)
     while let block = worklist.pop() {
       if case .recursive(let apply) = block.getKind(for: invariants, context) {
-        context.diagnosticEngine.diagnose(apply.location.sourceLoc, .warn_infinite_recursive_call)
+        context.diagnosticEngine.diagnose(.warn_infinite_recursive_call, at: apply.location)
       } else {
         for succ in block.successors where isInInfiniteRecursionLoop(succ) {
           worklist.pushIfNotVisited(succ)

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/LifetimeDependenceDiagnostics.swift

@@ -135,7 +135,7 @@ private struct DiagnoseDependence {
 
   func diagnose(_ position: SourceLoc?, _ id: DiagID,
                 _ args: DiagnosticArgument...) {
-    context.diagnosticEngine.diagnose(position, id, args)
+    context.diagnosticEngine.diagnose(id, args, at: position)
   }
 
   /// Check that this use is inside the dependence scope.

SwiftCompilerSources/Sources/Optimizer/ModulePasses/CMakeLists.txt

@@ -8,6 +8,7 @@
 
 swift_compiler_sources(Optimizer
   DiagnoseUnknownConstValues.swift
+  EmbeddedSwiftDiagnostics.swift
   MandatoryPerformanceOptimizations.swift
   ReadOnlyGlobalVariables.swift
   StackProtection.swift

SwiftCompilerSources/Sources/Optimizer/ModulePasses/DiagnoseUnknownConstValues.swift

@@ -39,8 +39,8 @@ let diagnoseUnknownConstValues = ModulePass(name: "diagnose-unknown-const-values
 private func verifyGlobals(_ context: ModulePassContext) {
   for gv in context.globalVariables where gv.isConst {
     if gv.staticInitValue == nil {
-      context.diagnosticEngine.diagnose(gv.varDecl?.location.sourceLoc,
-                                        .require_const_initializer_for_const)
+      context.diagnosticEngine.diagnose(.require_const_initializer_for_const,
+                                        at: gv.varDecl?.location.sourceLoc)
     }
   }
 }
@@ -66,8 +66,8 @@ private func verifyLocal(debugValueInst: DebugValueInst,
   }
 
   if !constExprState.isConstantValue(debugValueInst.operand.value) {
-    context.diagnosticEngine.diagnose(debugValueInst.location.sourceLoc,
-                                      .require_const_initializer_for_const)
+    context.diagnosticEngine.diagnose(.require_const_initializer_for_const,
+                                      at: debugValueInst.location)
   }
 }
 
@@ -92,8 +92,8 @@ private func verifyCallArguments(apply: FullApplySite,
   for (paramIdx, param) in calleeFn.convention.parameters.enumerated() where param.hasOption(.const) {
     let matchingOperand = apply.parameterOperands[paramIdx]
     if !constExprState.isConstantValue(matchingOperand.value) {
-      context.diagnosticEngine.diagnose(apply.location.sourceLoc,
-                                        .require_const_arg_for_parameter)
+      context.diagnosticEngine.diagnose(.require_const_arg_for_parameter,
+                                        at: apply.location)
     }
   }
 }