anchor.diff:          generateReturn il (returnValues,returnValuesField) (mi,result)
           il.MarkLabel(unmatched)
   
  +    /// Module builder
  +    let moduleBuilder = lazy (
  +        let name = "Foq.Dynamic"
  +        /// Builder for assembly
  +        let assemblyBuilder =
  +            AppDomain.CurrentDomain.DefineDynamicAssembly(AssemblyName(name),AssemblyBuilderAccess.Run)
  +        /// Builder for module
  +        assemblyBuilder.DefineDynamicModule(name+".dll")
  +        )
  +
       /// Defines a type builder for the specified abstract type
       let defineType (abstractType:Type) =
           /// Stub name for abstract type
  -        let mockName = "Mock." + abstractType.Name.Replace("'", "!")
  -        /// Builder for assembly
  -        let assemblyBuilder =
  -            AppDomain.CurrentDomain.DefineDynamicAssembly(AssemblyName(mockName),AssemblyBuilderAccess.Run)
  -        /// Builder for module
  -        let moduleBuilder = assemblyBuilder.DefineDynamicModule(mockName+".dll")
  +        let mockName = "Mock." + abstractType.Name.Replace("'", "!") + Guid.NewGuid().ToString()
           let parent, interfaces = 
               if abstractType.IsInterface
               then typeof<obj>, [|abstractType|]
               else abstractType, [||]
           let attributes = TypeAttributes.Public ||| TypeAttributes.Class
           let interfaces = [|yield typeof<IMockObject>; yield! interfaces|]
  -        moduleBuilder.DefineType(mockName, attributes, parent, interfaces)
  +        moduleBuilder.Value.DefineType(mockName, attributes, parent, interfaces)
   
       /// Builds a mock from the specified calls
       let mock (isStrict, abstractType:Type, calls:(MethodInfo * (Arg[] * Result)) list, args:obj[]) =
  
positive.code:         | PropertySet(Some(x), pi, args, value) ->
              [x, pi.GetSetMethod(),(toArgs [|yield! pi.GetIndexParameters(); yield null|] [yield! args; yield value], Unit)]
          | expr -> invalidOp(expr.ToString())
      let rec toCallResultOf abstractType expr =
          let calls = toCallResult expr
          [for (x,mi,(arg,result)) in calls -> 
  
negative.code:     open Eval
      /// Returns true if method has specified attribute
      let hasAttribute a (mi:MethodInfo) = mi.GetCustomAttributes(a, true).Length > 0
      /// Matches attributed calls
      let (|AttributedArg|_|) = function       
          | Call(_, mi, _) when hasAttribute typeof<WildcardAttribute> mi -> Some Any
          | Call(_, mi, [pred]) when hasAttribute typeof<PredicateAttribute> mi -> Some (Pred(eval pred))
          | _ -> None
      /// Converts parameter to arguments
      let rec toArg (pi:ParameterInfo,arg) =
          match pi, arg with
          | _, AttributedArg arg -> arg
          | pi, NewArray(_,args) when pi <> null && pi.GetCustomAttributes(typeof<ParamArrayAttribute>, true).Length > 0 ->
             ArgArray [|for arg in args -> toArg(null, arg)|]
          | _, expr -> eval expr |> Arg
      /// Converts parameters to arguments
      let toArgs ps args = [|for arg in Seq.zip ps args -> toArg arg |]
      /// Active pattern matches method call expressions
      let (|MethodCall|_|) expr =
  