public object Parse(ITypeBuilderRegistry registry, ITypeBuilder builder, object instanceState)
{
SkipWhitespace();
var c = Peek();
switch (c)
{
case '{':
return ParseObject(registry, builder, instanceState);
case '[':
return ParserArray(registry, builder, instanceState);
case '\"':
return ParseString(registry, builder);
case 't':
return ParseTrue(registry, builder);
case 'f':
return ParseFalse(registry, builder);
case 'n':
return ParseNull(registry, builder);
default:
if (char.IsDigit((char) c) || (c == '-'))
{
return ParseNumber(registry, builder);
}
break;
}
throw CreateException("Expected Json at ({1},{2})", c, Line, Column);
}
/// <summary>
/// Initializes a new instance of the <see cref="Poster"/> class.
/// </summary>
/// <param name="httpClientFactory">Http client factory.</param>
/// <param name="contentSerializer">Content serializer.</param>
/// <param name="httpClient">Http client.</param>
internal Poster(
IHttpClientFactory httpClientFactory,
IContentSerializer contentSerializer,
IHttpClient?httpClient = null)
{
_typeBuilder = new MockDynamicTypeBuilder(httpClientFactory, contentSerializer, httpClient);
}
private IReadOnlyList <StatementSyntaxNode> GenerateClassFields(ITypeBuilder type, IReadOnlyList <FieldSyntaxNode> fields, CodeGenerationStore store,
ISyntaxNode syntaxNode)
{
var definedFields = new List <IFieldInfo>();
var initExpressions = new List <StatementSyntaxNode>();
store.Fields.Add(type, definedFields);
foreach (var field in fields)
{
var fieldType = store.TypeDefLookup(field.Type);
typeChecker !.AssertTypeIsNotVoid(fieldType);
var definedField = type.DefineField(field.Name, fieldType, FieldAttributes.Public);
definedFields.Add(definedField);
if (field.Expression != null)
{
initExpressions.Add(new ExpressionEqualsExpressionSyntaxNode(field, new VariableSyntaxNode(field, field.Name), field.Expression));
}
}
initExpressions.Add(new BaseClassConstructorSyntax(syntaxNode));
return(initExpressions);
}
/// <summary>
/// Adds a constructor to the mixin type.
/// </summary>
/// <param name="typeBuilder">The <see cref="TypeBuilder"/> use to construct the type.</param>
/// <param name="mixinType">The mixin <see cref="Type"/> being created.</param>
/// <param name="baseTypesField">The <see cref="FieldBuilder"/> which will hold the instances of the base types.</param>
/// <param name="serviceProviderField">The <see cref="FieldBuilder"/> which will hold the instance of the dependency injection resolver.</param>
private void EmitConstructor(
ITypeBuilder typeBuilder,
Type mixinType,
IFieldBuilder baseTypesField,
IFieldBuilder serviceProviderField)
{
var constructorBuilder = typeBuilder
.NewConstructor()
.Public()
.HideBySig()
.SpecialName()
.RTSpecialName()
.CallingConvention(CallingConventions.HasThis)
.Param <object[]>("instances")
.Param <IServiceProvider>("serviceProvider");
constructorBuilder
.Body()
.LdArg0()
.LdArg1()
.StFld(baseTypesField)
.LdArg0()
.LdArg2()
.StFld(serviceProviderField)
.Ret();
}
public virtual void SetUp()
{
_mockRepository = new MockRepository();
_mutableType = MutableTypeObjectMother.Create();
_nestedTypeCodeGeneratorFactoryMock = _mockRepository.StrictMock <IMutableNestedTypeCodeGeneratorFactory>();
_codeGeneratorMock = _mockRepository.StrictMock <IReflectionEmitCodeGenerator>();
_emittableOperandProviderMock = _mockRepository.StrictMock <IEmittableOperandProvider> ();
_memberEmitterMock = _mockRepository.StrictMock <IMemberEmitter>();
_initializationBuilderMock = _mockRepository.StrictMock <IInitializationBuilder>();
_proxySerializationEnablerMock = _mockRepository.StrictMock <IProxySerializationEnabler>();
_generator = new MutableTypeCodeGenerator(
_mutableType,
_nestedTypeCodeGeneratorFactoryMock,
_codeGeneratorMock,
_emittableOperandProviderMock,
_memberEmitterMock,
_initializationBuilderMock,
_proxySerializationEnablerMock);
_typeBuilderMock = _mockRepository.StrictMock <ITypeBuilder>();
_debugInfoGeneratorMock = _mockRepository.StrictMock <DebugInfoGenerator>();
_fakeInitializationField = ReflectionObjectMother.GetSomeField();
_fakeInitializationMethod = ReflectionObjectMother.GetSomeMethod();
_fakeInitializationMembers = Tuple.Create(_fakeInitializationField, _fakeInitializationMethod);
}
/// <summary>
/// Adds a constructor to the mixin type.
/// </summary>
/// <param name="typeBuilder">The <see cref="TypeBuilder"/> use to construct the type.</param>
/// <param name="baseType">The base <see cref="Type"/> being ducked.</param>
/// <param name="baseTypeField">The <see cref="FieldBuilder"/> which will hold the instances of the base types.</param>
/// <param name="serviceProviderField">The <see cref="FieldBuilder"/> which will hold the instance of the dependency injection resolver.</param>
private void AddConstructor(
ITypeBuilder typeBuilder,
Type baseType,
IFieldBuilder baseTypeField,
IFieldBuilder serviceProviderField)
{
// Build Constructor.
var constructorBuilder = typeBuilder
.NewConstructor()
.Public()
.HideBySig()
.SpecialName()
.RTSpecialName()
.CallingConvention(CallingConventions.HasThis)
.Param(baseType, "target")
.Param <IServiceProvider>("serviceProvider");
constructorBuilder
.Body()
.LdArg0()
.Call(baseType.GetConstructor(new Type[0]))
.LdArg0()
.LdArg1()
.StFld(baseTypeField)
.LdArg0()
.LdArg2()
.StFld(serviceProviderField)
.Ret();
}
/// <summary>
/// Processes type builder attributes.
/// </summary>
/// <param name="typeBuilder">A type builder.</param>
/// <param name="type">The type to process the attributes for.</param>
/// <returns>The type builder instance.</returns>
public static ITypeBuilder ProcessAttributes(
this ITypeBuilder typeBuilder,
Type type)
{
foreach (var attr in type.GetCustomAttributes())
{
/*
* if (attr is SwaggerRequestHeaderParameterAttribute)
* {
* typeBuilder.SetCustomAttribute(
* AttributeUtility.BuildAttribute<string, SwaggerRequestHeaderParameterAttribute>(
* ((SwaggerRequestHeaderParameterAttribute)attr).Header,
* () => AttributeUtility.GetAttributePropertyValues<SwaggerRequestHeaderParameterAttribute>((SwaggerRequestHeaderParameterAttribute)attr, null)));
* }
* else
*/
if (attr is ObsoleteAttribute)
{
typeBuilder.SetCustomAttribute(
AttributeUtility.BuildAttribute <ObsoleteAttribute>(null));
}
}
return(typeBuilder);
}
public void SetUp()
{
_innerMock = MockRepository.GenerateStrictMock <ITypeBuilder> ();
_operandProvider = MockRepository.GenerateStrictMock <IEmittableOperandProvider> ();
_decorator = new TypeBuilderDecorator(_innerMock, _operandProvider);
}
private void GenerateClassMethods(ITypeBuilder type, IReadOnlyList <MethodSyntaxNode> methods, CodeGenerationStore store,
Dictionary <IMethodBuilder, MethodSyntaxNode> methodsDictionary, ref IMethodInfo?entryPoint)
{
var definedMethods = new List <IMethodInfo>();
store.Methods.Add(type, definedMethods);
foreach (var method in methods)
{
var methodAttributes = MethodAttributes.Public;
if (method.IsStatic)
{
methodAttributes |= MethodAttributes.Static;
}
var parameters = method.Parameters.Select(x =>
{
var tpe = store.TypeDefLookup(x.Type);
if (x.IsRef)
{
throw new RefTypeException("Ref types are not supported");
}
typeChecker !.AssertTypeIsNotVoid(tpe);
return(tpe);
}).ToArray();
var arrType = typeof(int[]);
var returnType = store.TypeDefLookup(method.ReturnType);
var definedMethod = type.DefineMethod(method.Name, methodAttributes, returnType, parameters, method.IsEntryPoint);
if (method.IsEntryPoint)
{
if (entryPoint != null)
{
throw new EntryPointException("Can only have 1 entry point");
}
entryPoint = definedMethod;
}
definedMethods.Add(definedMethod);
store.MethodParameters.Add(definedMethod, parameters);
methodsDictionary.Add(definedMethod, method);
int offset = 0;
//if (!method.IsStatic)
//{
// offset = 1;
//}
for (int i = 0; i < method.Parameters.Count; i++)
{
definedMethod.DefineParameter(i + 1 + offset, ParameterAttributes.None, method.Parameters[i].Name);
}
}
}
public static Type?GetType(object hashKey, Type sourceType, ITypeBuilder typeBuilder)
{
if (hashKey == null)
{
throw new ArgumentNullException(nameof(hashKey));
}
if (sourceType == null)
{
throw new ArgumentNullException(nameof(sourceType));
}
if (typeBuilder == null)
{
throw new ArgumentNullException(nameof(typeBuilder));
}
try
{
lock (_builtTypes)
{
Type?type;
if (_builtTypes.TryGetValue(typeBuilder.GetType(), out var builderTable))
{
if (builderTable.TryGetValue(hashKey, out type))
{
return(type);
}
}
else
{
_builtTypes.Add(typeBuilder.GetType(), builderTable = new Dictionary <object, Type>());
}
var assemblyBuilder = GetAssemblyBuilder(sourceType, typeBuilder.AssemblyNameSuffix);
type = typeBuilder.Build(assemblyBuilder);
if (type != null)
{
builderTable.Add(hashKey, type);
#if !NETCOREAPP2_0 && !NETCOREAPP2_1 && !NETCOREAPP2_2
SaveAssembly(assemblyBuilder, type);
#endif
}
return(type);
}
}
catch (TypeBuilderException)
{
throw;
}
catch (Exception ex)
{
// Convert an Exception to TypeBuilderException.
//
throw new TypeBuilderException($"Could not build the '{sourceType.FullName}' type.", ex);
}
}
public MultiTypeBuilder(IEnumerable <SyntaxTree> syntaxTrees, Compilation compilation, ITypeBuilder typeBuilder, IPatchParametersWalker walker)
{
_typesToWrap = new Stack <ITypeSymbol>();
_syntaxTrees = syntaxTrees ?? throw new ArgumentNullException(nameof(syntaxTrees));
_compilation = compilation ?? throw new ArgumentNullException(nameof(compilation));
_typeBuilder = typeBuilder ?? throw new ArgumentNullException(nameof(typeBuilder));
_walker = walker ?? throw new ArgumentNullException(nameof(walker));
}
/// <summary>
/// Creates a method.
/// </summary>
/// <param name="typeBuilder">A type builder.</param>
/// <param name="name">The name of the method.</param>
/// <returns>A method builder instance.</returns>
public static IMethodBuilder NewMethod <TReturn>(this ITypeBuilder typeBuilder, string name)
{
return(typeBuilder.NewMethod(
name,
MethodAttributes.Public,
CallingConventions.HasThis,
typeof(TReturn)));
}
private IReadOnlyList <ConstructorSyntaxNode> GenerateClassConstructors(ITypeBuilder type, IReadOnlyList <ConstructorSyntaxNode> constructors, CodeGenerationStore store,
IReadOnlyList <StatementSyntaxNode> fieldInitializers,
Dictionary <IConstructorBuilder, ConstructorSyntaxNode> constructorsDictionary, ISyntaxNode parent)
{
var initialConstructors = new List <ConstructorSyntaxNode>(constructors);
var mutatedConstructors = new List <ConstructorSyntaxNode>();
var definedConstructors = new List <IConstructorInfo>();
store.Constructors.Add(type, definedConstructors);
if (constructors.Count == 0)
{
var statementList = new List <StatementSyntaxNode>();
initialConstructors.Add(new ConstructorSyntaxNode(parent, Array.Empty <ParameterDefinitionSyntaxNode>(), statementList));
}
foreach (var constructor in initialConstructors)
{
var newStatements = new List <StatementSyntaxNode>(fieldInitializers);
foreach (var toAdd in constructor.Statements)
{
newStatements.Add(toAdd);
}
var mutatedConstructor = constructor.MutateStatements(newStatements);
mutatedConstructors.Add(mutatedConstructor);
var methodAttributes = MethodAttributes.Public;
var parameters = mutatedConstructor.Parameters.Select(x =>
{
var tpe = store.TypeDefLookup(x.Type);
if (x.IsRef)
{
throw new RefTypeException("Ref types are not supported");
}
typeChecker !.AssertTypeIsNotVoid(tpe);
return(tpe);
}).ToArray();
var definedConstructor = type.DefineConstructor(methodAttributes, parameters);
definedConstructors.Add(definedConstructor);
store.ConstructorParameters.Add(definedConstructor, parameters);
constructorsDictionary.Add(definedConstructor, mutatedConstructor);
int offset = 0;
for (int i = 0; i < mutatedConstructor.Parameters.Count; i++)
{
definedConstructor.DefineParameter(i + 1 + offset, ParameterAttributes.None, mutatedConstructor.Parameters[i].Name);
}
}
return(mutatedConstructors);
}
public IQueryBuilder WithType(string key, Func <ITypeBuilder, ITypeBuilder> predicate)
{
ITypeBuilder builder = predicate(new GraphQLQueryTypeBuilder(key));
if (builder.Types.Count == 0 && builder.Parameters.Count == 0)
{
return(WithObject(key));
}
return(WithType(builder.ToType()));
}
/// <summary>
/// Resolves an object based on the type specified
/// </summary>
/// <param name="Name">Name of the object to return</param>
/// <param name="ObjectType">Object type</param>
/// <param name="DefaultObject">Default value if type is not registered or error occurs</param>
/// <returns>Object of the type specified</returns>
public override object Resolve(Type ObjectType, string Name, object DefaultObject = null)
{
try
{
var Key = new Tuple <Type, string>(ObjectType, Name);
ITypeBuilder Builder = null;
return(_AppContainer.TryGetValue(Key, out Builder) ? Builder.Create() : DefaultObject);
}
catch { return(DefaultObject); }
}
public CodeFileBuilder AddType(ITypeBuilder value)
{
if (value is null)
{
throw new ArgumentNullException(nameof(value));
}
_types.Add(value);
return(this);
}
private void Register(Type target, ITypeBuilder builder)
{
if (!_builders.ContainsKey(target))
{
_builders.Add(target, builder.Create);
}
else
{
throw new InvalidOperationException($"Duplicate registration for type {target.FullName}");
}
}
/// <summary>
/// Initializes a new instance of the <see cref="TypeFactoryContext"/> class.
/// </summary>
/// <param name="typeBuilder">The <see cref="TypeBuilder"/> being use to create the type.</param>
/// <param name="newType">The new type being built.</param>
/// <param name="baseType">The base type being built on.</param>
/// <param name="serviceProvider">The current dependency injection scope</param>
/// <param name="baseObjectField">The <see cref="FieldBuilder"/> that holds the base type instance.</param>
/// <param name="serviceProviderField">The <see cref="FieldBuilder"/> that holds the <see cref="IServiceProvider"/> instance.</param>
/// <param name="ctorBuilder">The <see cref="ConstructorBuilder"/> for the types constructor.</param>
public TypeFactoryContext(
ITypeBuilder typeBuilder,
Type newType,
Type baseType,
IServiceProvider serviceProvider,
IFieldBuilder baseObjectField,
IFieldBuilder serviceProviderField,
IConstructorBuilder ctorBuilder = null)
: this(typeBuilder, newType, new Type[] { baseType }, serviceProvider, baseObjectField, serviceProviderField, ctorBuilder)
{
}
/// <summary>
/// Initialises a new instance of the <see cref="FluentPropertyBuilder"/> class.
/// </summary>
/// <param name="typeBuilder">A <see cref="ITypeBuilder"/> instance.</param>
/// <param name="propertyName">The name of the property.</param>
/// <param name="propertyType">The property type.</param>
/// <param name="define">A function to define the property.</param>
public FluentPropertyBuilder(
ITypeBuilder typeBuilder,
string propertyName,
Type propertyType,
Func <string, PropertyAttributes, CallingConventions, Type, Type[], Type[], Type[], Type[][], Type[][], PropertyBuilder> define)
{
this.define = define;
this.typeBuilder = typeBuilder;
this.name = propertyName;
this.propertyType = propertyType;
this.PropertyAttributes = PropertyAttributes.None;
}
public static CodeGenerationContext GetSomeContext(
MutableType mutableType = null,
ITypeBuilder typeBuilder = null,
DebugInfoGenerator debugInfoGenerator = null,
IEmittableOperandProvider emittableOperandProvider = null)
{
return(new CodeGenerationContext(
mutableType ?? MutableTypeObjectMother.Create(),
typeBuilder ?? new Mock <ITypeBuilder>().Object,
debugInfoGenerator ?? new Mock <DebugInfoGenerator>().Object,
emittableOperandProvider ?? new Mock <IEmittableOperandProvider>().Object));
}
public SynchronisationWrapper(
ITypeBuilder typeBuilder,
IMethodBuilder methodBuilder,
ISynchronisationTypeTranslator synchronisationTypeTranslator,
TypeDefinition type)
{
this.m_TypeBuilder = typeBuilder;
this.m_MethodBuilder = methodBuilder;
this.m_SynchronisationTypeTranslator = synchronisationTypeTranslator;
this.m_Type = type;
this.m_TraceSource = new TraceSource("SynchronisationWrapper");
}
public SynchronisationWrapper(
ITypeBuilder typeBuilder,
IMethodBuilder methodBuilder,
ISynchronisationTypeTranslator synchronisationTypeTranslator,
TypeDefinition type)
{
this.m_TypeBuilder = typeBuilder;
this.m_MethodBuilder = methodBuilder;
this.m_SynchronisationTypeTranslator = synchronisationTypeTranslator;
this.m_Type = type;
this.m_TraceSource = new TraceSource("SynchronisationWrapper");
}
public CodeGenerationContext(
MutableType mutableType, ITypeBuilder typeBuilder, DebugInfoGenerator debugInfoGeneratorOrNull, IEmittableOperandProvider emittableOperandProvider)
{
ArgumentUtility.CheckNotNull("mutableType", mutableType);
ArgumentUtility.CheckNotNull("typeBuilder", typeBuilder);
ArgumentUtility.CheckNotNull("emittableOperandProvider", emittableOperandProvider);
_mutableType = mutableType;
_typeBuilder = typeBuilder;
_debugInfoGenerator = debugInfoGeneratorOrNull;
_emittableOperandProvider = emittableOperandProvider;
}
/// <summary>
/// Initializes a new instance of the <see cref="ProxyBuilderContext"/> class.
/// </summary>
/// <param name="typeBuilder">The <see cref="TypeBuilder"/> being use to create the type.</param>
/// <param name="newType">The new type being built.</param>
/// <param name="baseType">The base type being built on.</param>
/// <param name="baseObjectField">The <see cref="FieldBuilder"/> that holds the base type instance.</param>
/// <param name="ctorBuilder">The <see cref="ConstructorBuilder"/> for the types constructor.</param>
public ProxyBuilderContext(
ITypeBuilder typeBuilder,
Type newType,
Type baseType,
IFieldBuilder baseObjectField,
IConstructorBuilder ctorBuilder = null)
: this(typeBuilder,
newType,
new Type[] { baseType },
baseObjectField,
ctorBuilder)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="ProxyBuilderContext"/> class.
/// </summary>
/// <param name="typeBuilder">The <see cref="TypeBuilder"/> being use to create the type.</param>
/// <param name="newType">The new type being built.</param>
/// <param name="baseTypes">The base types being built on.</param>
/// <param name="baseObjectField">The <see cref="FieldBuilder"/> that holds the base type instance.</param>
/// <param name="ctorBuilder">The <see cref="ConstructorBuilder"/> for the types constructor.</param>
public ProxyBuilderContext(
ITypeBuilder typeBuilder,
Type newType,
Type[] baseTypes,
IFieldBuilder baseObjectField,
IConstructorBuilder ctorBuilder = null)
{
this.TypeBuilder = typeBuilder;
this.NewType = newType;
this.BaseTypes = baseTypes;
this.BaseObjectField = baseObjectField;
this.ConstructorBuilder = ctorBuilder;
}
/// <summary>
/// Implements the interface and any of it descendent interfaces.
/// </summary>
/// <param name="typeBuilder">A type builder.</param>
/// <param name="interfaceType">The interface type.</param>
/// <returns>The type builder.</returns>
public static ITypeBuilder ImplementsInterfaces(this ITypeBuilder typeBuilder, Type interfaceType)
{
typeBuilder.Implements(interfaceType);
Type[] implementedInterfaces = interfaceType.GetInterfaces();
if (implementedInterfaces.IsNullOrEmpty() == false)
{
foreach (Type type in implementedInterfaces)
{
typeBuilder.ImplementsInterfaces(type);
}
}
return(typeBuilder);
}
public IMutableTypeCodeGenerator Create(ITypeBuilder enclosingTypeBuilder, MutableType nestedType)
{
ArgumentUtility.CheckNotNull("enclosingTypeBuilder", enclosingTypeBuilder);
ArgumentUtility.CheckNotNull("nestedType", nestedType);
return(new MutableNestedTypeCodeGenerator(
enclosingTypeBuilder,
nestedType,
this,
_reflectionEmitCodeGenerator,
_emittableOperandProvider,
_memberEmitter,
_initializationBuilder,
_proxySerializationEnabler));
}
/// <summary>
/// Initializes a new instance of the <see cref="ProxyGenerator"/> class.
/// </summary>
/// <param name="typeBuilder">The type builder.</param>
/// <param name="interceptionFilter">The interception filter.</param>
public ProxyGenerator(ITypeBuilder typeBuilder, IInterceptionFilter interceptionFilter)
{
if (typeBuilder == null)
throw new ArgumentNullException("typeBuilder");
if (interceptionFilter == null)
throw new ArgumentNullException("interceptionFilter");
_typeBuilder = typeBuilder;
_interceptionFilter = interceptionFilter;
_eventInfos = new List<EventInfo>();
_propertyInfos = new List<PropertyInfo>();
_methodInfos = new List<MethodInfo>();
}
/// <summary>
/// Implements the interfaces and any of their descendent interfaces.
/// </summary>
/// <param name="typeBuilder">A type builder.</param>
/// <param name="interfaceTypes">The interface type.</param>
/// <returns>The type builder.</returns>
public static ITypeBuilder ImplementsInterfaces(this ITypeBuilder typeBuilder, params Type[] interfaceTypes)
{
foreach (var interfaceType in interfaceTypes)
{
typeBuilder.Implements(interfaceType);
Type[] baseTypes = interfaceType.GetInterfaces();
if (baseTypes.IsNullOrEmpty() == false)
{
typeBuilder.ImplementsInterfaces(baseTypes);
}
}
return(typeBuilder);
}
public void SetUp()
{
_expressionPreparerMock = MockRepository.GenerateStrictMock <IExpressionPreparer>();
_ilGeneratorFactoryStub = MockRepository.GenerateStub <IILGeneratorFactory>();
_emitter = new MemberEmitter(_expressionPreparerMock, _ilGeneratorFactoryStub);
_typeBuilderMock = MockRepository.GenerateStrictMock <ITypeBuilder>();
_emittableOperandProviderMock = MockRepository.GenerateStrictMock <IEmittableOperandProvider>();
_context = CodeGenerationContextObjectMother.GetSomeContext(
typeBuilder: _typeBuilderMock, emittableOperandProvider: _emittableOperandProviderMock);
_fakeBody = ExpressionTreeObjectMother.GetSomeExpression();
}
public void SetUp()
{
_enclosingTypeBuilderMock = MockRepository.GenerateStrictMock <ITypeBuilder>();
_mutableType = MutableTypeObjectMother.Create();
_generator = new MutableNestedTypeCodeGenerator
(
_enclosingTypeBuilderMock,
_mutableType,
MockRepository.GenerateStub <IMutableNestedTypeCodeGeneratorFactory>(),
MockRepository.GenerateStub <IReflectionEmitCodeGenerator>(),
MockRepository.GenerateStub <IEmittableOperandProvider>(),
MockRepository.GenerateStub <IMemberEmitter>(),
MockRepository.GenerateStub <IInitializationBuilder>(),
MockRepository.GenerateStub <IProxySerializationEnabler>());
}
/// <summary>
/// Initializes a new instance of the <see cref="TypeFactoryContext"/> class.
/// </summary>
/// <param name="typeBuilder">The <see cref="ITypeBuilder"/> being use to create the type.</param>
/// <param name="newType">The new type being built.</param>
/// <param name="baseTypes">The base types being built on.</param>
/// <param name="serviceProvider">The current dependency injection scope</param>
/// <param name="baseObjectField">The <see cref="IFieldBuilder"/> that holds the base type instance.</param>
/// <param name="serviceProviderField">The <see cref="IFieldBuilder"/> that holds the <see cref="IServiceProvider"/> instance.</param>
/// <param name="ctorBuilder">The <see cref="ConstructorBuilder"/> for the Itypes constructor.</param>
public TypeFactoryContext(
ITypeBuilder typeBuilder,
Type newType,
Type[] baseTypes,
IServiceProvider serviceProvider,
IFieldBuilder baseObjectField,
IFieldBuilder serviceProviderField,
IConstructorBuilder ctorBuilder = null)
{
this.TypeBuilder = typeBuilder;
this.NewType = newType;
this.BaseTypes = baseTypes;
this.ServiceProvider = serviceProvider;
this.BaseObjectField = baseObjectField;
this.ServiceProviderField = serviceProviderField;
this.ConstructorBuilder = ctorBuilder;
}
/// <summary>
/// Implements the <see cref="IMixinObject"/> interface on the mixin type.
/// </summary>
/// <param name="typeBuilder">The <see cref="TypeBuilder"/> use to construct the type.</param>
/// <param name="baseTypeField">The <see cref="FieldBuilder"/> which will hold the instances of the types that make up the mixin.</param>
private void EmitMixinObjectInterface(
ITypeBuilder typeBuilder,
IFieldBuilder baseTypeField)
{
var propertyMixinObjects = typeBuilder
.NewProperty <object[]>("MixinObjects")
.Getter(m => m
.Public()
.Virtual()
.HideBySig()
.NewSlot()
.CallingConvention(CallingConventions.HasThis)
.Body(il => il
.LdArg0()
.LdFld(baseTypeField)
.Ret()));
}
public Scope(CodeGenerator generator, ILBuilder il, bool isFunction, BoundBody body, BoundClosureField argumentsClosureField, ITypeBuilder typeBuilder, Scope parent)
{
IL = il;
ArgumentsClosureField = argumentsClosureField;
Generator = generator;
_isFunction = isFunction;
_body = body;
if (argumentsClosureField != null)
ArgumentsEmitter = new ClosureFieldEmitter(generator, argumentsClosureField);
TypeBuilder = typeBuilder;
Parent = parent;
_isStatic = TypeBuilder is IScriptBuilder;
if (body.MappedArguments != null)
_arguments = body.MappedArguments.ToDictionary(p => p.Argument, p => p.Mapped);
BreakTargets = new Stack<NamedLabel>();
ContinueTargets = new Stack<NamedLabel>();
}
protected object ParseFalse(ITypeBuilderRegistry registry, ITypeBuilder builder)
{
Match("false");
return builder.CreateBool(registry, false);
}
private IFunctionBuilder DeclareFunction(BoundFunction function, ITypeBuilder typeBuilder, string sourceCode)
{
var method = typeBuilder.CreateFunction(typeof(JsFunction), function.Name, sourceCode);
var argumentsReferenced = (function.Body.Flags & BoundBodyFlags.ArgumentsReferenced) != 0;
BoundClosureField argumentsClosureField = null;
var il = method.GetILBuilder();
if (argumentsReferenced && function.Body.Closure != null)
function.Body.Closure.Fields.TryGetValue(BoundClosure.ArgumentsFieldName, out argumentsClosureField);
_scope = new Scope(
this,
il,
true,
function.Body,
argumentsClosureField,
typeBuilder,
_scope
);
_scope.EmitLocals(function.Body.TypeManager);
// Instantiate the closure if we own it.
if (function.Body.Closure != null)
EmitClosureSetup(function.Body);
EmitInitializeArguments(function.Body);
// Build the arguments object when we need it.
if (argumentsReferenced)
{
// Initialize the arguments array.
_scope.ArgumentsEmitter.EmitSetValue(new BoundEmitExpression(
BoundValueType.Object,
() =>
{
_scope.EmitLoad(SpecialLocal.Runtime);
_scope.EmitLoad(SpecialLocal.Callee);
_scope.EmitLoad(SpecialLocal.ArgumentsRaw);
IL.EmitCall(_runtimeCreateArguments);
}
));
}
// Emit the body.
EmitStatements(function.Body.Body);
// Ensure that we return something.
EmitReturn(new BoundReturn(null, SourceLocation.Missing));
// Emit the exceptional return block if we need it.
EmitExceptionalReturn();
// Put a debug location at the end of the function.
if (function.Location != null)
{
IL.MarkSequencePoint(new SourceLocation(
function.Location.EndOffset,
function.Location.EndLine,
function.Location.EndColumn,
function.Location.EndOffset + 1,
function.Location.EndLine,
function.Location.EndColumn + 1,
null
));
}
_scope = _scope.Parent;
return method;
}
/// <summary>
/// Initializes a new instance of the <see cref="TypesRepository" /> class.
/// </summary>
internal TypesRepository(ITypeBuilder typeBuilder)
{
_typeBuilder = typeBuilder;
_typeConstructor = new ConcurrentDictionary<Type, ConstructorInfo>();
}
/*
* number = [ minus ] int [ frac ] [ exp ]
* decimal-point = %x2E ; .
* digit1-9 = %x31-39 ; 1-9
* e = %x65 / %x45 ; e E
* exp = e [ minus / plus ] 1*DIGIT
* frac = decimal-point 1*DIGIT
* int = zero / ( digit1-9 *DIGIT )
* minus = %x2D ; -
* plus = %x2B ; +
* zero = %x30 ; 0
*/
private object ParseNumber(ITypeBuilderRegistry registry, ITypeBuilder builder)
{
var startLine = Line;
var startColumn = Column;
var sb = new StringBuilder();
if (Peek() == '-')
{
sb.Append(Next());
}
var hasInteger = false;
while (char.IsDigit((char) Peek()))
{
sb.Append(Next());
hasInteger = true;
}
if (!hasInteger)
{
throw CreateExpectedNumberException(startLine, startColumn);
}
if (Peek() != '.')
{
long intValue;
if (!long.TryParse(sb.ToString(), out intValue))
{
throw CreateExpectedNumberException(startLine, startColumn);
}
return builder.CreateNumber(registry, intValue);
}
sb.Append(Next());
var hasFrac = false;
while (char.IsDigit((char) Peek()))
{
sb.Append(Next());
hasFrac = true;
}
if (!hasFrac)
{
throw CreateExpectedNumberException(startLine, startColumn);
}
if ("eE".IndexOf((char) Peek()) >= 0)
{
sb.Append(Next());
if ("+-".IndexOf((char) Peek()) >= 0)
{
sb.Append(Next());
}
var hasExp = false;
while (char.IsDigit((char) Peek()))
{
sb.Append(Next());
hasExp = true;
}
if (!hasExp)
{
throw CreateExpectedNumberException(startLine, startColumn);
}
}
double doubleValue;
if (!double.TryParse(sb.ToString(),
NumberStyles.AllowLeadingSign | NumberStyles.AllowDecimalPoint |
NumberStyles.AllowExponent,
JsonFormats.DoubleFormat, out doubleValue))
{
throw CreateExpectedNumberException(startLine, startColumn);
}
return builder.CreateNumber(registry, doubleValue);
}
protected object ParseNull(ITypeBuilderRegistry registry, ITypeBuilder builder)
{
Match("null");
return builder.CreateNull(registry);
}
protected object ParseString(ITypeBuilderRegistry registry, ITypeBuilder builder)
{
var s = ParseString();
var dt = JsonFormats.TryParseDateTime(s);
return dt.HasValue ? builder.CreateDateTime(registry, dt.Value, s) : builder.CreateString(registry, s);
}
protected object ParserArray(ITypeBuilderRegistry registry, ITypeBuilder builder, object instanceState)
{
Match('[');
SkipWhitespace();
var arrayBuilder = builder.CreateArrayBuilder(registry);
var array = arrayBuilder.CreateNewArray(registry, instanceState);
while (Peek() != ']')
{
arrayBuilder.AddElement(array, Parse(registry, arrayBuilder.GetElementBuilder(registry), null));
SkipWhitespace();
if (!TryMatch(','))
{
break;
}
SkipWhitespace();
}
Match(']');
return arrayBuilder.GetArray(array);
}
public static Type GetType(Type sourceType, ITypeBuilder typeBuilder)
{
return GetType(sourceType, sourceType, typeBuilder);
}
public static Type GetType(object hashKey, Type sourceType, ITypeBuilder typeBuilder)
{
if (hashKey == null) throw new ArgumentNullException("hashKey");
if (sourceType == null) throw new ArgumentNullException("sourceType");
if (typeBuilder == null) throw new ArgumentNullException("typeBuilder");
try
{
Hashtable builderTable = (Hashtable)_builtTypes[typeBuilder.GetType()];
Type type;
if (builderTable != null)
{
type = (Type)builderTable[hashKey];
if (type != null)
return type;
}
lock (_builtTypes.SyncRoot)
{
builderTable = (Hashtable)_builtTypes[typeBuilder.GetType()];
if (builderTable != null)
{
type = (Type)builderTable[hashKey];
if (type != null)
return type;
}
else
{
_builtTypes.Add(typeBuilder.GetType(), builderTable = new Hashtable());
}
AssemblyBuilderHelper assemblyBuilder =
GetAssemblyBuilder(sourceType, typeBuilder.AssemblyNameSuffix);
type = typeBuilder.Build(sourceType, assemblyBuilder);
if (type != null)
{
builderTable.Add(hashKey, type);
SaveAssembly(assemblyBuilder, type);
}
return type;
}
}
catch (TypeBuilderException)
{
throw;
}
catch (Exception ex)
{
throw new TypeBuilderException(string.Format(
"Could not build the '{0}' type: {1}", sourceType.FullName, ex.Message), ex);
}
}
protected ConvertingTypeBuilder(ITypeBuilder inner, Func<object, object> convert)
{
_inner = inner;
_convert = convert;
}
public void Initialize(IServiceContainer source)
{
_createAdapterType = source.GetService<ITypeBuilder>("CreateAdapterType");
}
protected object ParseTrue(ITypeBuilderRegistry registry, ITypeBuilder builder)
{
Match("true");
return builder.CreateBool(registry, true);
}
protected object ParseObject(ITypeBuilderRegistry registry, ITypeBuilder builder, object instanceState)
{
Match('{');
SkipWhitespace();
var objectBuilder = builder.CreateObjectBuilder(registry);
var @object = objectBuilder.CreateNewObject(registry, instanceState);
while (Peek() != '}')
{
var memberName = ParseString();
SkipWhitespace();
Match(':');
var memberState = objectBuilder.GetMemberState(memberName, @object);
objectBuilder.SetMember(memberName, @object,
Parse(registry, objectBuilder.GetMemberBuilder(registry, memberName),
memberState));
SkipWhitespace();
if (!TryMatch(','))
{
break;
}
SkipWhitespace();
}
Match('}');
return objectBuilder.GetObject(@object);
}
