Merge branch 'main' of github.com:hylo-lang/hylo into range-of-non-comparable

Author: kyouko-taiga

Docs/CLI.md

@@ -48,6 +48,10 @@ Import the built-in module.  Allows using Hylo's built-in types and functions (e
 
 Do not include the standard library module.
 
+### `--freestanding`
+
+Compile in freestanding mode (don't use libc).
+
 ### `--typecheck`
 
 Type-check the input file(s).  Exits the compilation pipeline after type-checking and does not produce an output file.

Sources/CodeGen/LLVM/Transpilation.swift

@@ -934,6 +934,11 @@ extension LLVM.Module {
         let source = llvm(s.operands[0])
         register[.register(i)] = insertZeroExtend(source, to: target, at: insertionPoint)
 
+      case .sext(_, let t):
+        let target = ir.llvm(builtinType: t, in: &self)
+        let source = llvm(s.operands[0])
+        register[.register(i)] = insertSignExtend(source, to: target, at: insertionPoint)
+
       case .inttoptr(_):
         let source = llvm(s.operands[0])
         register[.register(i)] = insertIntToPtr(source, at: insertionPoint)

Sources/Core/AST/AST+Walk.swift

@@ -706,7 +706,7 @@ extension AST {
   public func traverse<O: ASTWalkObserver>(
     _ n: ConditionalCompilationStmt, notifying o: inout O
   ) {
-    walk(roots: n.expansion, notifying: &o)
+    walk(roots: n.expansion(for: compiler), notifying: &o)
   }
 
   /// Visits the children of `n` in pre-order, notifying `o` when a node is entered or left.

Sources/Core/AST/AST.swift

@@ -20,10 +20,18 @@ public struct AST {
     /// The module containing Hylo's core library, if any.
     public var coreLibrary: ModuleDecl.ID?
 
+    /// Information about the compiler processing `self`.
+    public let compiler: CompilerConfiguration
+
+    /// Creates an empty AST for given compiler.
+    public init(for compiler: CompilerConfiguration) {
+      self.compiler = compiler
+    }
+
   }
 
   /// The notional stored properties of `self`; distinguished for encoding/decoding purposes.
-  private var storage = Storage()
+  private var storage: Storage
 
   /// The traits in Hylo's standard library that are known by the compiler.
   public var coreTraits: CoreTraits?
@@ -50,8 +58,15 @@ public struct AST {
     set { storage.coreLibrary = newValue }
   }
 
+  /// Information about the compiler processing `self`.
+  public var compiler: CompilerConfiguration {
+    return storage.compiler
+  }
+
   /// Creates an empty AST.
-  public init() {}
+  public init(for compiler: CompilerConfiguration) {
+    self.storage = Storage(for: compiler)
+  }
 
   /// Inserts `n` into `self`, updating `diagnostics` if `n` is ill-formed.
   public mutating func insert<T: Node>(_ n: T, diagnostics: inout DiagnosticSet) -> T.ID {
@@ -121,10 +136,10 @@ public struct AST {
   public func coreType(_ name: String) -> ProductType? {
     precondition(isCoreModuleLoaded, "Core library is not loaded")
 
-    for id in topLevelDecls(coreLibrary!) where id.kind == ProductTypeDecl.self {
-      let id = ProductTypeDecl.ID(id)!
-      if self[id].baseName == name {
-        return ProductType(id, ast: self)
+    for d in topLevelDecls(coreLibrary!) where d.kind == ProductTypeDecl.self {
+      let d = ProductTypeDecl.ID(d)!
+      if self[d].baseName == name {
+        return ProductType(d, ast: self)
       }
     }
 
@@ -169,8 +184,8 @@ public struct AST {
     modules.first(where: { self[$0].baseName == n })
   }
 
-  /// Returns the IDs of the top-level declarations in the lexical scope of `module`.
-  public func topLevelDecls(_ module: ModuleDecl.ID) -> some Collection<AnyDeclID> {
+  /// Returns the top-level declarations in the lexical scope of `module`.
+  private func topLevelDecls(_ module: ModuleDecl.ID) -> some Collection<AnyDeclID> {
     self[self[module].sources].map(\.decls).joined()
   }
 

Sources/Core/AST/BundledNode.swift

@@ -49,8 +49,8 @@ extension BundledNode where T: ConcreteNodeID {
 extension BundledNode where T: ScopeID {
 
   /// The declarations in this immediate scope.
-  public var decls: [AnyDeclID] {
-    container.scopeToDecls[id, default: []]
+  public var decls: DeclIDs {
+    container.scopeToDecls[id, default: .init()]
   }
 
 }

Sources/Core/AST/NodeIDs/DeclID.swift

@@ -5,7 +5,7 @@ public protocol DeclID: NodeIDProtocol {}
 
 extension DeclID {
 
-  /// Indicates whether `self` denotes an overloadable declaration.
+  /// `true` iff `self` denotes an overloadable declaration.
   public var isOverloadable: Bool {
     switch kind {
     case FunctionDecl.self, InitializerDecl.self, MethodDecl.self, SubscriptDecl.self:
@@ -25,6 +25,11 @@ extension DeclID {
     (kind.value as! Decl.Type).isCallable
   }
 
+  /// `true` iff `self` denotes a type extending declaration.
+  public var isTypeExtendingDecl: Bool {
+    (kind == ExtensionDecl.self) || (kind == ConformanceDecl.self)
+  }
+
   /// `true` iff `self` denotes a conformance source.
   public var isConformanceSource: Bool {
     kind.value is ConformanceSource.Type

Sources/Core/AST/NodeIDs/DeclIDs.swift

@@ -0,0 +1,86 @@
+import Utils
+
+/// A collection of declaration identifiers.
+public struct DeclIDs {
+
+  /// Instances are notionally the concatenation of two collections `front` and `back` such that
+  /// `front` only contains type extending declarations and `back` contains none. `insert(_:)`
+  /// maintains this invariant as well as the relative order of the elements in these collections.
+
+  /// All identifiers in `self`.
+  private(set) var all: [AnyDeclID]
+
+  /// The position immediately after the last ID of a type extending declaration in `all`.
+  private var extensionEndIndex: Int
+
+  /// Creates an empty instance.
+  public init() {
+    all = []
+    extensionEndIndex = 0
+  }
+
+  /// Creates an instance with the contents of each collection in `batch`.
+  public init<S: Sequence<DeclIDs>>(formingUnionOf batch: S) {
+    all = []
+
+    var end: [AnyDeclID] = []
+    for c in batch {
+      all.append(contentsOf: c[..<c.extensionEndIndex])
+      end.append(contentsOf: c[c.extensionEndIndex...])
+    }
+
+    extensionEndIndex = all.endIndex
+    all.append(contentsOf: end)
+  }
+
+  /// The identifiers in `self` denoting type extending declarations.
+  public var extensions: ArraySlice<AnyDeclID> {
+    all[0 ..< extensionEndIndex]
+  }
+
+  /// The identifiers in `self` _not_ denoting type extending declarations.
+  public var withoutExtensions: ArraySlice<AnyDeclID> {
+    all[extensionEndIndex...]
+  }
+
+  /// Inserts `d` in `self`.
+  public mutating func insert(_ d: AnyDeclID) {
+    if d.isTypeExtendingDecl {
+      all.insert(d, at: extensionEndIndex)
+      extensionEndIndex += 1
+    } else {
+      all.append(d)
+    }
+  }
+
+}
+
+extension DeclIDs: Equatable {}
+
+extension DeclIDs: RandomAccessCollection {
+
+  public typealias Index = Int
+
+  public typealias Element = AnyDeclID
+
+  public var startIndex: Int { 0 }
+
+  public var endIndex: Int { all.endIndex }
+
+  public func index(after position: Int) -> Int {
+    position + 1
+  }
+
+  public func index(before position: Int) -> Int {
+    position - 1
+  }
+
+  public func index(_ position: Int, offsetBy distance: Int) -> Int {
+    position + distance
+  }
+
+  public subscript(position: Int) -> AnyDeclID {
+    all[position]
+  }
+
+}

Sources/Core/AST/Stmt/ConditionalCompilationStmt.swift

@@ -69,7 +69,7 @@ public struct ConditionalCompilationStmt: Stmt {
     }
 
     /// Returns `true` iff `self` holds for the current process.
-    public func holds(for info: CompilerInfo) -> Bool {
+    public func holds(for info: CompilerConfiguration) -> Bool {
       switch self {
       case .`true`: return true
       case .`false`: return false
@@ -108,8 +108,8 @@ public struct ConditionalCompilationStmt: Stmt {
   }
 
   /// Returns the statements that this expands to.
-  public var expansion: [AnyStmtID] {
-    if condition.holds(for: CompilerInfo.instance) {
+  public func expansion(for compiler: CompilerConfiguration) -> [AnyStmtID] {
+    if condition.holds(for: compiler) {
       return stmts
     } else {
       return fallback

Sources/Core/CompilerInfo.swift

@@ -1,5 +1,5 @@
 /// Describes the compiler; used as source of truth for conditional compilation.
-public struct CompilerInfo {
+public struct CompilerConfiguration: Codable {
 
   /// The operating-system used when performing the compilation.
   let os: String
@@ -19,17 +19,14 @@ public struct CompilerInfo {
   /// The set of features supported in the current compilation.
   let features: [String]
 
-  /// We only need one instance of this struct, to represent the compiler information.
-  public static let instance = CompilerInfo()
-
-  /// Creates an instance with the properties of the machine running this initializer.
-  private init() {
-    os = CompilerInfo.currentOS()
-    arch = CompilerInfo.currentArch()
+  /// Creates an instance with the properties of the machine running this initializer, using features `f`.
+  public init(_ f: [String] = []) {
+    os = CompilerConfiguration.currentOS()
+    arch = CompilerConfiguration.currentArch()
     compiler = "hc"
     compilerVersion = SemanticVersion(major: 0, minor: 1, patch: 0)
     hyloVersion = SemanticVersion(major: 0, minor: 1, patch: 0)
-    features = ["useLibC"]
+    features = f
   }
 
   /// The name of the operating system on which this function is run.

Sources/Core/Conformance.swift

@@ -22,6 +22,15 @@ public struct Conformance {
       }
     }
 
+    /// `true` iff `self` is synthetic.
+    public var isSynthetic: Bool {
+      if case .synthetic = self {
+        return true
+      } else {
+        return false
+      }
+    }
+
   }
 
   /// The type on the left-hand side of this conformance.

Sources/Core/Program.swift

@@ -9,8 +9,8 @@ public protocol Program {
   /// A map from node to the innermost scope that contains it.
   var nodeToScope: ASTProperty<AnyScopeID> { get }
 
-  /// A map from scope to the declarations directly contained in them.
-  var scopeToDecls: ASTProperty<[AnyDeclID]> { get }
+  /// A map from scope to the declarations that it contains.
+  var scopeToDecls: ASTProperty<DeclIDs> { get }
 
   /// A map from variable declaration its containing binding declaration.
   var varToBinding: [VarDecl.ID: BindingDecl.ID] { get }