anchor.diff:  
           /// The type of the implicit constructor, representing as a ValScheme.
           InstanceCtorValScheme: ValScheme
  -        
  +
           /// The values representing the arguments to the implicit constructor.
           InstanceCtorArgs: Val list
   
  
positive.code:     }
  
  /// Indicates how is a 'let' bound value in a class with implicit construction is represented in
  /// the TAST ultimately produced by type checking.    
  type IncrClassValRepr = 
  
      // e.g representation for 'let v = 3' if it is not used in anything given a method representation
      | InVar of isArg: bool 
  
      // e.g representation for 'let v = 3'
      | InField of isStatic: bool * staticCountForSafeInit: int * fieldRef: RecdFieldRef
  
      // e.g representation for 'let f x = 3'
      | InMethod of isStatic:bool * value: Val * valReprInfo: ValReprInfo
  
  /// IncrClassReprInfo represents the decisions we make about the representation of 'let' and 'do' bindings in a
  /// type defined with implicit class construction.
  type IncrClassReprInfo = 
      { 
          /// Indicates the set of field names taken within one incremental class
          TakenFieldNames: Set<string>
            
          RepInfoTcGlobals: TcGlobals
            
          /// vals mapped to representations
          ValReprs: Zmap<Val, IncrClassValRepr> 
            
          /// vals represented as fields or members from this point on 
          ValsWithRepresentation: Zset<Val> 
      }
  
      static member IsMethodRepr: cenv: TcFileState -> bind: Binding -> bool
  
      // Publish the fields of the representation to the type 
      member PublishIncrClassFields: 
          cenv : TcFileState * 
          denv : DisplayEnv * 
          cpath : CompilationPath * 
          ctorInfo: IncrClassCtorLhs * 
          safeStaticInitInfo : SafeInitData 
            -> unit    
  
      /// Given localRep saying how locals have been represented, e.g. as fields.
      /// Given an expr under a given thisVal context.
      member FixupIncrClassExprPhase2C: 
          cenv : TcFileState -> 
          thisValOpt : Val option -> 
          safeStaticInitInfo : SafeInitData -> 
          thisTyInst: TypeInst -> 
          expr : Expr -> 
          Expr 
  
  /// Represents a single group of bindings in a class with an implicit constructor
  type IncrClassBindingGroup = 
      | IncrClassBindingGroup of bindings: Binding list * isStatic: bool* isRecursive: bool
      | IncrClassDo of expr: Expr * isStatic: bool * range: Range 
  
  type IncrClassConstructionBindingsPhase2C =
      | Phase2CBindings of IncrClassBindingGroup list
      | Phase2CCtorJustAfterSuperInit     
      | Phase2CCtorJustAfterLastLet
  
  /// Check and elaborate the "left hand side" of the implicit class construction 
  /// syntax.
  val TcImplicitCtorLhs_Phase2A: 
      cenv: TcFileState * 
      env: TcEnv * 
      tpenv: UnscopedTyparEnv * 
      tcref: TyconRef * 
      vis: SynAccess option * 
      attrs : SynAttribute list * 
      spats : SynSimplePat list * 
      thisIdOpt : Ident option * 
      baseValOpt: Val option * 
      safeInitInfo : SafeInitData * 
      m : range * 
      copyOfTyconTypars : Typar list * 
      objTy : TType * 
      thisTy : TType * 
      xmlDoc: PreXmlDoc 
        -> IncrClassCtorLhs
  
  /// <summary>
  /// Given a set of 'let' bindings (static or not, recursive or not) that make up a class,
  
negative.code:     cenv: TcFileState *
      env: TcEnv *
      ctorInfo: IncrClassCtorLhs *
      inheritsExpr: Expr *
      inheritsIsVisible: bool *
      decs: IncrClassConstructionBindingsPhase2C list *
      memberBinds: Binding list *
      generalizedTyparsForRecursiveBlock: Typar list *
      safeStaticInitInfo: SafeInitData ->
          Expr * Expr option * Binding list * IncrClassReprInfo
  