anchor.diff:                          emitExpr (ilg, locals, parameterVars) ExpectedStackState.Value argExpr
                       ilg.Emit(OpCodes.Call,cinfo)
   
  -                for ctorArgsAsFieldIdx,ctorArgsAsField in List.mapi (fun i x -> (i,x)) implicitCtorArgsAsFields do 
  -                    ilg.Emit(OpCodes.Ldarg_0)
  -                    ilg.Emit(OpCodes.Ldarg, ctorArgsAsFieldIdx+1)
  -                    ilg.Emit(OpCodes.Stfld, ctorArgsAsField)
  -                    
  +                if pcinfo.IsImplicitCtor then
  +                    for ctorArgsAsFieldIdx,ctorArgsAsField in List.mapi (fun i x -> (i,x)) implicitCtorArgsAsFields do 
  +                        ilg.Emit(OpCodes.Ldarg_0)
  +                        ilg.Emit(OpCodes.Ldarg, ctorArgsAsFieldIdx+1)
  +                        ilg.Emit(OpCodes.Stfld, ctorArgsAsField)
  +                else
  +                    let code  = pcinfo.GetInvokeCodeInternal true
  +                    let code = code parameters
  +                    emitExpr (ilg, locals, parameterVars) ExpectedStackState.Empty code
                   ilg.Emit(OpCodes.Ret)
               
               match ptd.GetConstructors(ALL) |> Seq.tryPick (function :? ProvidedConstructor as pc when pc.IsTypeInitializer -> Some pc | _ -> None) with
  
positive.code:                 [ for ctorArg in implictCtorArgs -> 
                        tb.DefineField(ctorArg.Name, convType ctorArg.ParameterType, FieldAttributes.Private) ]
              
              let uniqueLambdaTypeName = 
                  let counter = ref 0
                  fun () -> 
                      let n = !counter 
                      incr counter 
                      sprintf "Lambda%d" n
              let rec emitLambda(callSiteIlg : ILGenerator, v : Quotations.Var, body : Quotations.Expr, freeVars : seq<Quotations.Var>, locals : Dictionary<_, LocalBuilder>) =
                  let lambda = assemblyMainModule.DefineType(uniqueLambdaTypeName(), TypeAttributes.Class)
                  let baseType = typedefof<FSharpFunc<_, _>>.MakeGenericType(v.Type, body.Type)
  
negative.code:                           ilg.Emit(OpCodes.Castclass, targetTy)
                                
                          popIfEmptyExpected expectedState
                      | Quotations.DerivedPatterns.SpecificCall <@ (-) @>(None, [t1; t2; t3], [a1; a2]) ->
                          assert(t1 = t2)
                          emit ExpectedStackState.Value a1
                          emit ExpectedStackState.Value a2
                          if t1 = typeof<decimal> then
                              ilg.Emit(OpCodes.Call, typeof<decimal>.GetMethod "op_Subtraction")
                          else
                              ilg.Emit(OpCodes.Sub)
                              emitConvIfNecessary t1
  
                          popIfEmptyExpected expectedState
  
                      | Quotations.DerivedPatterns.SpecificCall <@ (/) @> (None, [t1; t2; t3], [a1; a2]) ->
                          assert (t1 = t2)
                          emit ExpectedStackState.Value a1
                          emit ExpectedStackState.Value a2
                          if t1 = typeof<decimal> then
                              ilg.Emit(OpCodes.Call, typeof<decimal>.GetMethod "op_Division")
                          else
                              match Type.GetTypeCode t1 with
                              | TypeCode.UInt32
                              | TypeCode.UInt64
                              | TypeCode.UInt16
                              | TypeCode.Byte
                              | _ when t1 = typeof<unativeint> -> ilg.Emit (OpCodes.Div_Un)
                              | _ -> ilg.Emit(OpCodes.Div)
  
                              emitConvIfNecessary t1
  
                          popIfEmptyExpected expectedState
  
                      | Quotations.DerivedPatterns.SpecificCall <@ int @>(None, [sourceTy], [v]) ->
                          emit ExpectedStackState.Value v
                          match Type.GetTypeCode(sourceTy) with
                          | TypeCode.String -> 
                              ilg.Emit(OpCodes.Call, Misc.ParseInt32Method)
                          | TypeCode.Single
                          | TypeCode.Double
                          | TypeCode.Int64 
                          | TypeCode.UInt64
                          | TypeCode.UInt16
                          | TypeCode.Char
                          | TypeCode.Byte
                          | _ when sourceTy = typeof<nativeint> || sourceTy = typeof<unativeint> ->
                              ilg.Emit(OpCodes.Conv_I4)
                          | TypeCode.Int32
                          | TypeCode.UInt32
                          | TypeCode.Int16
                          | TypeCode.SByte -> () // no op
                          | _ -> failwith "TODO: search for op_Explicit on sourceTy"
  
                      | Quotations.DerivedPatterns.SpecificCall <@ LanguagePrimitives.IntrinsicFunctions.GetArray @> (None, [ty], [arr; index]) ->
                          // observable side-effect - IndexOutOfRangeException
  