anchor.diff:  
   /// Identifies a constructor implementation shape
   and [<Sealed>] ShapeConstructor<'DeclaringType, 'CtorArgs> private (ctorInfo : ConstructorInfo, arity : int) =
  +#if TYPESHAPE_EMIT
  +    let ctorf = emitConstructorFunc<'CtorArgs, 'DeclaringType> arity ctorInfo
  +#else
       let valueReader = 
           match arity with
           | 0 -> fun _ -> [||]
           | 1 -> fun x -> [|x|]
           |_ -> FSharpValue.PreComputeTupleReader typeof<'CtorArgs>
  +#endif
   
       /// Creates an instance of declaring type with supplied constructor args
       member _.Invoke(args : 'CtorArgs) =
  +#if TYPESHAPE_EMIT
  +        ctorf.Invoke args
  +#else
           let args = valueReader args
           ctorInfo.Invoke args :?> 'DeclaringType
  +#endif
  +
   
   #if TYPESHAPE_EXPR
       /// Creates an instance of declaring type with supplied constructor args
  
positive.code:                     f.SetValue(currentTuple, nestedTuple)
                      currentTuple <- nestedTuple
                  tuple :?> 'Tuple)
  
      member _.IsStructTuple = typeof<'Tuple>.IsValueType
      /// Tuple element shape definitions
  
negative.code:         emitDynamicMethod<Setter<'DeclaringType, 'Property>>
              injectionId [|typeof<'DeclaringType>.MakeByRefType(); typeof<'Property>|] typeof<System.Void> builder
  
      let ldDefaultValue (gen : ILGenerator) (t : Type) =
          if not t.IsValueType then gen.Emit OpCodes.Ldnull
          elif t = typeof<bool> || t = typeof<byte> || t = typeof<sbyte> ||
              t = typeof<char> || t = typeof<uint16> || t = typeof<int16> ||
              t = typeof<int32> || t = typeof<uint32> then
              gen.Emit OpCodes.Ldc_I4_0
          elif t = typeof<int64> || t = typeof<uint64> then
              gen.Emit OpCodes.Ldc_I4_0 ; gen.Emit OpCodes.Conv_I8
          elif t = typeof<single> then gen.Emit(OpCodes.Ldc_R4, 0.0f)
          elif t = typeof<double> then gen.Emit(OpCodes.Ldc_R8, 0.0)
          elif t = typeof<IntPtr> then gen.Emit OpCodes.Ldc_I4_0; gen.Emit OpCodes.Conv_I
          elif t = typeof<UIntPtr> then gen.Emit OpCodes.Ldc_I4_0; gen.Emit OpCodes.Conv_U
          else
              assert(not t.IsPrimitive)
              let lvar = gen.DeclareLocal t
              gen.Emit(OpCodes.Ldloca_S, lvar.LocalIndex)
              gen.Emit(OpCodes.Initobj, t)
              gen.Emit(OpCodes.Ldloc, lvar.LocalIndex)
          
  
      /// Emits a dynamic method that injects uninitialized values to supplied static method or ctor
      let emitUninitializedCtor<'DeclaringType> (ctor : MethodBase) =
          let builder (gen : ILGenerator) =
              for p in ctor.GetParameters() do ldDefaultValue gen p.ParameterType
  
              match ctor with
              | :? ConstructorInfo as c -> gen.Emit(OpCodes.Newobj, c)
  