         guard let bind = tc.signature.lookupMetaBinding(mv) else {
           fatalError("Unbound meta!?")
         }
-        return self.lower(bind.body)
-      case .variable(_): fatalError()
+        return self.lower(bind.body, in: env)
+      case .variable(_):
+        fatalError()
       }
     case .equal(_, _, _):
       fatalError("FIXME: Emit metadata here")

  /// Retrieves the type lowering for a TT-type.
  public func lowerType(_ type: Type<TT>) -> Lowering {
    let key = self.getTypeKey(type)

    if let existing = self.loweringCache[key] {
      return existing
    }

    let resolvedKey = self.getTypeKey(self.resolveMetaIfNeeded(type))
    if let existing = self.loweringCache[resolvedKey] {
      return existing
    }

    let info = self.lower(type)
    self.loweringCache[key] = info
    self.loweringCache[resolvedKey] = info
    self.loweringCache[CacheKey(loweredType: info.type)] = info
    return info
  }

  /// Retrieves the lowering information for a previously-lowered type.

  public weak var module: GIRModule?
  private let tc: TypeChecker<CheckPhaseState>

  var wildcardName: Name {
    return Name(name: SyntaxFactory.makeUnderscore(presence: .implicit))
  }

  /// A `Lowering` describes extended type information used by GIRGen when
  /// interacting with lowered values.
  public class Lowering {
    enum Status {
      case incomplete(name: QualifiedName)
      case complete(type: GIRType, trivial: Bool, addressOnly: Bool)
    }

    public var isComplete: Bool {
      switch self.status {
      case .complete(type: _, trivial: _, addressOnly: _):
        return true
      default:
        return false
      }
    }

    public var name: QualifiedName {
      switch self.status {
      case let .incomplete(name: name):
        return name
      default:
        fatalError()
      }
    }

    /// The canonicalized lowered type.
    public var type: GIRType {
      switch self.status {
      case let .complete(type: ty, trivial: _, addressOnly: _):
        return ty
      default:
        fatalError("Incomplete lowering!")
      }
    }
    /// A trivial type is a loadable type with trivial value semantics - they
    /// may be loaded and stored without semantic copy or destroy operations.
    public var trivial: Bool {
      switch self.status {
      case let .complete(type: _, trivial: tr, addressOnly: _):
        return tr
      default:
        fatalError("Incomplete lowering!")
      }
    }
    /// An address-only type is a non-loadable value whose underlying
    /// representation is opaque.  It does not make sense to load from the
    /// address carried by values of this type, hence it is "Address Only".
    public var addressOnly: Bool {
      switch self.status {
      case let .complete(type: _, trivial: _, addressOnly: ao):
        return ao
      default:
        fatalError("Incomplete lowering!")
      }
    }

    private var status: Status

    init(name: QualifiedName) {
      self.status = .incomplete(name: name)
    }

    init(type: GIRType, isTrivial: Bool, isAddressOnly: Bool) {
      self.status = .complete(type: type, trivial: isTrivial,
                              addressOnly: isAddressOnly)
    }

    private func complete(type: GIRType, isTrivial: Bool, isAddressOnly: Bool) {
      self.status = .complete(type: type, trivial: isTrivial,
                              addressOnly: isAddressOnly)
    }

    func completeTrivial(type: GIRType) -> Lowering {
      self.complete(type: type, isTrivial: true, isAddressOnly: false)
      return self
    }

    func completeNonTrivial(type: GIRType) -> Lowering {
      self.complete(type: type, isTrivial: false, isAddressOnly: false)
      return self
    }

    func completeTrivialAddressOnly(type: GIRType) -> Lowering {
      self.complete(type: type, isTrivial: true, isAddressOnly: true)
      return self
    }

    func completeAddressOnly(type: GIRType) -> Lowering {
      self.complete(type: type, isTrivial: false, isAddressOnly: true)
      return self
    }
  }

  private struct CacheKey: Hashable {
    fileprivate enum Constant {
      case star
      case archetype
    }

    private enum Details: Hashable {
