Merge pull request #1053 from hylo-lang/generic-captures

Avoid over-capturing generic arguments in declaration references

Sources/CodeGen/LLVM/Transpilation.swift

@@ -1,6 +1,6 @@
 import Core
-import IR
 import Foundation
+import IR
 import LLVM
 import Utils
 
@@ -335,7 +335,7 @@ extension LLVM.Module {
   private mutating func demandMetatype<T: TypeProtocol>(
     of t: T, usedIn m: IR.Module, from ir: IR.Program,
     initializedWith initializeInstance: (inout Self, LLVM.GlobalVariable) -> Void
-  ) -> LLVM.GlobalVariable{
+  ) -> LLVM.GlobalVariable {
     let globalName = ir.base.mangled(t)
     if let g = global(named: globalName) { return g }
 

Sources/Core/CompileTimeValues/GenericArguments.swift

@@ -36,9 +36,10 @@ public struct GenericArguments {
   public init<S: Sequence>(
     skolemizing parameters: S, in ast: AST
   ) where S.Element == GenericParameterDecl.ID {
-    self.contents = .init(uniqueKeysWithValues: parameters.map { (p) in
-      (key: p, value: ^GenericTypeParameterType(p, ast: ast))
-    })
+    self.contents = .init(
+      uniqueKeysWithValues: parameters.map { (p) in
+        (key: p, value: ^GenericTypeParameterType(p, ast: ast))
+      })
   }
 
   /// A collection with the parameters to which arguments are passed.

Sources/Core/Program.swift

@@ -156,6 +156,8 @@ extension Program {
       return true
     case SubscriptDecl.self:
       return ast[SubscriptDecl.ID(decl)!].isStatic
+    case VarDecl.self:
+      return isGlobal(varToBinding[VarDecl.ID(decl)!]!)
     default:
       return false
     }

Sources/FrontEnd/TypeChecking/TypeChecker.swift

@@ -3270,14 +3270,18 @@ struct TypeChecker {
     inScopeIntroducing d: AnyDeclID, resolvedIn context: NameResolutionContext?
   ) -> GenericArguments {
     if let a = context?.arguments { return a }
-
-    // References to modules can never capture any generic arguments.
-    if d.kind == ModuleDecl.self { return [:] }
+    if !mayCaptureGenericParameters(d) { return [:] }
 
     let parameters = accumulatedGenericParameters(in: program[d].scope)
     return .init(skolemizing: parameters, in: program.ast)
   }
 
+  /// Returns `true` if a reference to `d` may capture generic parameters from the surrounding
+  /// lookup context.
+  private func mayCaptureGenericParameters(_ d: AnyDeclID) -> Bool {
+    d.kind.value is GenericScope.Type
+  }
+
   /// Associates `parameters`, which are introduced by `name`'s declaration, to corresponding
   /// values in `arguments` if the two arrays have the same length. Otherwise, returns `nil`,
   /// reporting diagnostics to `log`.

Sources/FrontEnd/TypedProgram.swift

@@ -264,6 +264,23 @@ public struct TypedProgram {
     return result
   }
 
+  /// Returns the generic parameters captured in the scope of `d` if `d` is callable. Otherwise,
+  /// returns an empty collection.
+  public func liftedGenericParameters(of d: AnyDeclID) -> [GenericParameterDecl.ID] {
+    switch d.kind {
+    case FunctionDecl.self:
+      return Array(accumulatedGenericParameters(in: FunctionDecl.ID(d)!))
+    case InitializerDecl.self:
+      return Array(accumulatedGenericParameters(in: InitializerDecl.ID(d)!))
+    case SubscriptImpl.self:
+      return Array(accumulatedGenericParameters(in: SubscriptImpl.ID(d)!))
+    case MethodImpl.self:
+      return Array(accumulatedGenericParameters(in: MethodImpl.ID(d)!))
+    default:
+      return []
+    }
+  }
+
   /// Returns generic parameters captured by `s` and the scopes semantically containing `s`.
   public func accumulatedGenericParameters<T: ScopeID>(
     in s: T

Sources/IR/Analysis/Module+Depolymorphize.swift

@@ -127,6 +127,14 @@ extension Module {
     _ f: Function.ID, in ir: IR.Program,
     for specialization: GenericArguments, in scopeOfUse: AnyScopeID
   ) -> Function.ID {
+    // TODO: Avoid monomorphizing non-generic entities (#
+    // let parameters = ir.base.liftedGenericParameters(of: f)
+    // if parameters.isEmpty {
+    //   return f
+    // }
+    // let specialization = GenericArguments(
+    //   uniqueKeysWithValues: parameters.map({ ($0, specialization[$0]!) }))
+
     let result = demandMonomorphizedDeclaration(of: f, in: ir, for: specialization, in: scopeOfUse)
     if self[result].entry != nil {
       return result
@@ -567,3 +575,25 @@ extension Module {
   }
 
 }
+
+extension TypedProgram {
+
+  /// Returns the generic parameters captured in the scope of `f`.
+  fileprivate func liftedGenericParameters(of f: Function.ID) -> [GenericParameterDecl.ID] {
+    switch f.value {
+    case .lowered(let d):
+      return liftedGenericParameters(of: d)
+
+    case .synthesized(let d):
+      if let a = BoundGenericType(d.receiver)?.arguments {
+        return Array(a.keys)
+      } else {
+        return []
+      }
+
+    case .existentialized, .monomorphized:
+      return []
+    }
+  }
+
+}