Merge pull request #1087 from hylo-lang/typecheck-for-stmt

Type check for loops

Library/Hylo/Core/Bool.hylo

@@ -25,23 +25,30 @@ public type Bool {
     Bool(value: Builtin.or_i1(self.value, rhs.value))
   }
 
-  /// Returns `true` if `self` is equal to `other`. Otherwise, returns `false`.
-  public fun infix== (_ other: Self) -> Bool {
-    Bool(value: Builtin.icmp_eq_i1(value, other.value))
-  }
-
-  /// Returns `true` if `self` is not equal to `other`. Otherwise, returns `false`.
-  public fun infix!= (_ other: Self) -> Bool {
-    Bool(value: Builtin.icmp_ne_i1(value, other.value))
-  }
 }
 
 public conformance Bool: Deinitializable {}
 
+public conformance Bool: Movable {}
+
 public conformance Bool: Copyable {
 
   public fun copy() -> Self {
     Bool(value: value)
   }
 
 }
+
+public conformance Bool: Equatable {
+
+  public fun infix== (_ other: Self) -> Bool {
+    Bool(value: Builtin.icmp_eq_i1(value, other.value))
+  }
+
+  public fun infix!= (_ other: Self) -> Bool {
+    Bool(value: Builtin.icmp_ne_i1(value, other.value))
+  }
+
+}
+
+public conformance Bool: Regular {}

Library/Hylo/Core/CollectionOfOne.hylo

@@ -1,8 +1,6 @@
 /// A collection containing a single element.
 public type CollectionOfOne<Element: Movable & Deinitializable>: Deinitializable {
 
-  public typealias Index = Bool
-
   /// The element contained in `self`.
   var contents: Element
 
@@ -11,6 +9,12 @@ public type CollectionOfOne<Element: Movable & Deinitializable>: Deinitializable
     &self.contents = contents
   }
 
+}
+
+public conformance CollectionOfOne: Collection {
+
+  public typealias Index = Bool
+
   public fun start_index() -> Bool { false }
 
   public fun end_index() -> Bool { true }

Library/Hylo/Core/Iterator.hylo

@@ -0,0 +1,21 @@
+/// A type that supplies the elements of a list one at a type.
+///
+/// An iterator encapsulates the necessary state and logic to produce the elements of a possibly
+/// unbounded list, one after the other.  Elements are returned by `next()`, which returns either
+/// the next element in the list or `None` if all elements have been returned.
+///
+/// Use `Iterator` to implement single-pass iteration algorithms that take ownership of the values
+/// on which they iterate. You can "step through" the elements of an iterator using a for-loop:
+///
+///     for let x in some_iterator { print(x) }
+///
+/// An `Iterator` typically does not model a `Collection`.
+public trait Iterator {
+
+  /// The type of the elements produced by `Self`.
+  type Element
+
+  /// Advances to the next element and returns it, or `None` if no next element exists.
+  fun next() inout -> Optional<Element>
+
+}

Library/Hylo/Core/Numbers/Integers/Int.hylo

@@ -52,6 +52,8 @@ public conformance Int: ExpressibleByIntegerLiteral {}
 
 public conformance Int: Deinitializable {}
 
+public conformance Int: Movable {}
+
 public conformance Int: Copyable {
 
   public fun copy() -> Self {
@@ -72,6 +74,8 @@ public conformance Int: Equatable {
 
 }
 
+public conformance Int: Regular {}
+
 public conformance Int: Comparable {
 
   public fun infix< (_ other: Self) -> Bool {

Library/Hylo/Core/Regular.hylo

@@ -8,4 +8,4 @@ public trait SemiRegular: Deinitializable, Movable, Equatable {}
 /// Regular types (roughly per Stepanov).
 ///
 /// Copies have equal value.
-public trait Regular: Deinitializable, Copyable, Movable, Equatable {}
+public trait Regular: SemiRegular, Copyable {}

Sources/Core/AST/Decl/ConformanceDecl.swift

@@ -1,5 +1,5 @@
 /// A declaration that extends a type with new conformances.
-public struct ConformanceDecl: TypeExtendingDecl {
+public struct ConformanceDecl: ConformanceSource, TypeExtendingDecl {
 
   public static let constructDescription = "conformance declaration"
 

Sources/Core/AST/Decl/ConformanceSource.swift

@@ -0,0 +1,7 @@
+/// The declaration of a type's conformance to one or multiple traits.
+public protocol ConformanceSource: ExposableDecl {
+
+  /// The names of traits to which the type conforms.
+  var conformances: [NameExpr.ID] { get }
+
+}

Sources/Core/AST/Decl/ProductTypeDecl.swift

@@ -1,5 +1,5 @@
 /// A (nominal) product type declaration.
-public struct ProductTypeDecl: ExposableDecl, GenericDecl, SingleEntityDecl, GenericScope {
+public struct ProductTypeDecl: ConformanceSource, GenericDecl, SingleEntityDecl, GenericScope {
 
   public static let constructDescription = "product type declaration"
 

Sources/Core/AST/Pattern/BindingPattern.swift

@@ -6,6 +6,7 @@ import Utils
 /// bindings, instead of referring to existing declarations.
 public struct BindingPattern: Pattern {
 
+  /// An introducer in a binding pattern.
   public enum Introducer: Codable {
 
     case `let`
@@ -16,6 +17,11 @@ public struct BindingPattern: Pattern {
 
     case `inout`
 
+    /// `true` if `self` is `var` or `sinklet`.
+    public var isConsuming: Bool {
+      (self == .var) || (self == .sinklet)
+    }
+
   }
 
   public let site: SourceRange

Sources/Core/ConformanceOrigin.swift

@@ -0,0 +1,16 @@
+/// The declaration and site from which an explicit conformance originates.
+public struct ConformanceOrigin {
+
+  /// The declaration of the conformance.
+  public let source: AnyDeclID
+
+  /// The site at which diagnostics related to the conformance are reported.
+  public let site: SourceRange
+
+  /// Creates an instance with the given properties.
+  public init<T: ConformanceSource>(_ source: T.ID, at site: SourceRange) {
+    self.source = AnyDeclID(source)
+    self.site = site
+  }
+
+}

Sources/FrontEnd/TypeChecking/BindingDeclUse.swift

@@ -0,0 +1,31 @@
+import Core
+
+/// How a binding declaration is being used.
+enum BindingDeclUse: Hashable {
+
+  /// The declaration is used to introduce new bindings unconditionally.
+  ///
+  /// The pattern matches any possible value produced by the declaration's initializer, if present.
+  case irrefutable
+
+  /// The declaration is used as a condition.
+  ///
+  /// The pattern acts as a condition that is satisfied iff it matches the value of the
+  /// declaration's initializer, which must be present.
+  case condition
+
+  /// The declaration is used as a filter.
+  ///
+  /// The pattern acts as a condition that is satisfied iff it matches an instance of the payload.
+  case filter(matching: AnyType)
+
+  /// The type that is narrowed by the pattern of the declaration if it is used as a filter.
+  var filteredType: AnyType? {
+    if case .filter(let t) = self {
+      return t
+    } else {
+      return nil
+    }
+  }
+
+}

Sources/FrontEnd/TypeChecking/TypeChecker+Diagnostics.swift

@@ -332,6 +332,18 @@ extension Diagnostic {
     .error("right operand of built-in pointer conversion must be a remote type", at: site)
   }
 
+  static func error(
+    invalidForLoopDomain m: AnyType, consuming: Bool, at site: SourceRange
+  ) -> Diagnostic {
+    if consuming {
+      return .error(
+        "consuming for loop requires '\(m)' to conform to 'Iterator'", at: site)
+    } else {
+      return .error(
+        "non-consuming for loop requires '\(m)' to conform to 'Collection' or 'Iterator'", at: site)
+    }
+  }
+
   static func warning(needlessImport d: ImportDecl.ID, in ast: AST) -> Diagnostic {
     let s = ast[d].identifier
     return .warning("needless import: source file is part of '\(s.value)'", at: s.site)