/// <summary> /// Build auto generated property from given <see cref="TypeMethodInfo" />. /// </summary> /// <param name="methodInfo">Info of method that will be generated.</param> /// <returns>MethodItem.</returns> private static MethodItem buildAutoProperty(TypeMethodInfo methodInfo) { var buildGetter = !methodInfo.ReturnType.Equals(TypeDescriptor.Void); var methodName = methodInfo.MethodName; var propertyStorage = buildGetter ? methodName.Substring(Naming.GetterPrefix.Length) : methodName.Substring(Naming.SetterPrefix.Length); propertyStorage = "@" + propertyStorage; if (buildGetter) { var getterGenerator = new DirectGenerator((c) => { var fieldValue = c.GetField(c.CurrentArguments[0], propertyStorage) as Instance; c.Return(fieldValue); }); return(new MethodItem(getterGenerator, methodInfo)); } else { var setterGenerator = new DirectGenerator((c) => { var setValue = c.CurrentArguments[1]; c.SetField(c.CurrentArguments[0], propertyStorage, setValue); }); return(new MethodItem(setterGenerator, methodInfo)); } }
/// <summary> /// Makes the specified search path. /// </summary> /// <param name="searchPath">The search path.</param> /// <param name="methodDefinition">The method definition.</param> /// <returns>MethodItem.</returns> public MethodItem Make(PathInfo searchPath, TypeMethodInfo methodDefinition) { var genericMethod = methodDefinition.MakeGenericMethod(searchPath); var generator = new RuntimeMethodGenerator(_method, genericMethod, ImplementTypes); return(new MethodItem(generator, genericMethod)); }
public ParsedGenerator(TypeMethodInfo info, string sourceCode, IEnumerable <string> genericParameters, TypeServices services) { if (info == null) { throw new ArgumentNullException("info"); } if (sourceCode == null) { throw new ArgumentNullException("sourceCode"); } if (genericParameters == null) { throw new ArgumentNullException("genericParameters"); } if (services == null) { throw new ArgumentNullException("services"); } SourceCode = sourceCode; Method = info; _services = services; _genericParameters = genericParameters; }
/// <summary> /// Transcript given instructions in context of given method. /// Transcription is processed by given emitter. /// </summary> /// <param name="method">Context method of transcription</param> /// <param name="instructions">Transcripted instructions</param> /// <param name="emitter">Emitter where transcription is emitted</param> internal static void Transcript(TypeMethodInfo method, IEnumerable <CILInstruction> instructions, EmitterBase emitter) { E = emitter; Method = method; LocalTmpVar = E.GetTemporaryVariable("local"); //prepare labels table Labels.Clear(); foreach (var instruction in instructions) { var labelName = string.Format("L_0x{0:x4}", instruction.Address); Labels.Add(instruction.Address, E.CreateLabel(labelName)); } foreach (var instruction in instructions) { Instruction = instruction; E.SetLabel(Labels[instruction.Address]); var block = E.StartNewInfoBlock(); block.Comment = "\n---" + Instruction.ToString(); Action transcriptor; if (_transcriptors.TryGetValue(Name, out transcriptor)) { transcriptor(); } else { unknownInstruction(); } } }
protected override void generate(EmitterBase emitter) { var namespaces = _declaringAssembly.GetNamespaces(_compositionAttribute.Element as CodeElement); var initializerMethodInfo = new TypeMethodInfo(_compositionPoint.DeclaringType, ParsingActivation.InlineMethodName, TypeDescriptor.Void, ParameterTypeInfo.NoParams, false, TypeDescriptor.NoDescriptors); var code = new StringBuilder(); code.AppendLine("{"); for (var i = 0; i < _compositionPoint.Parameters.Length; ++i) { var parameter = _compositionPoint.Parameters[i]; var argument = _compositionAttribute.GetArgument(i); if (argument == null) { argument = "null"; } code.AppendLine(" var arg" + i + " = " + argument + ";"); } code.AppendLine("}"); var activation = new ParsingActivation(code.ToString(), initializerMethodInfo, new string[0], namespaces); _declaringAssembly.ParsingProvider(activation, emitter); }
public MethodItem Make(PathInfo methodPath, TypeMethodInfo methodDefinition) { var genericMethod = methodDefinition.MakeGenericMethod(methodPath); var generator = this.makeGeneric(genericMethod); return(new MethodItem(generator, genericMethod)); }
public MethodItem Make(PathInfo searchPath, TypeMethodInfo genericMethod) { var newMethod = genericMethod.MakeGenericMethod(searchPath); var newGenerator = new ParsedGenerator(newMethod, SourceCode, _genericParameters, _services); return(new MethodItem(newGenerator, newMethod)); }
/// <summary> /// Creates <see cref="TypeMethodInfo" /> for given element. /// </summary> /// <param name="element">Element which <see cref="TypeMethodInfo" /> is created.</param> /// <returns>Created <see cref="TypeMethodInfo" />.</returns> internal TypeMethodInfo BuildFrom(CodeVariable element) { var isShared = element.IsShared; var isAbstract = false; //variables cannot be abstract var declaringType = CreateDescriptor(element.Parent as CodeClass); var variableType = CreateDescriptor(element.Type); //variables cannot have type arguments var methodTypeArguments = TypeDescriptor.NoDescriptors; TypeDescriptor returnType; ParameterTypeInfo[] parameters; var buildGetter = RequiredName.StartsWith(Naming.GetterPrefix); if (buildGetter) { returnType = variableType; parameters = ParameterTypeInfo.NoParams; } else { returnType = TypeDescriptor.Void; parameters = new[] { ParameterTypeInfo.Create("value", variableType) }; } var methodInfo = new TypeMethodInfo( declaringType, RequiredName, returnType, parameters, isShared, methodTypeArguments, isAbstract ); return(methodInfo); }
/// <summary> /// Initializes a new instance of the <see cref="ParsingActivation" /> class. /// </summary> /// <param name="sourceCode">The source code.</param> /// <param name="method">The method.</param> /// <param name="genericParameters">The generic parameters.</param> /// <param name="namespaces">The namespaces.</param> /// <exception cref="System.ArgumentNullException">genericParameters /// or /// method</exception> public ParsingActivation(string sourceCode, TypeMethodInfo method, IEnumerable <string> genericParameters, IEnumerable <string> namespaces = null) { /* if (sourceCode == null) * throw new ArgumentNullException("sourceCode");*/ if (genericParameters == null) { throw new ArgumentNullException("genericParameters"); } if (method == null) { throw new ArgumentNullException("method"); } if (namespaces == null) { namespaces = new string[0]; } SourceCode = sourceCode; Method = method; //create defensive copy GenericParameters = genericParameters.ToArray(); //create defensive copy Namespaces = namespaces.ToArray(); }
private static void emitCtor(TypeMethodInfo ctor) { var arguments = emitPopArguments(ctor); E.AssignNewObject(LocalTmpVar, ctor.DeclaringType); E.Call(ctor.MethodID, LocalTmpVar, arguments); emitPushFrom(LocalTmpVar); }
private static Arguments emitPopArguments(TypeMethodInfo info) { var argumentVariables = from param in info.Parameters select emitPopTmp(param.Type); argumentVariables = argumentVariables.Reverse(); var arguments = Arguments.Values(argumentVariables.ToArray()); return(arguments); }
/// <summary> /// Create TypeMethodInfo from given methodInfo. /// </summary> /// <param name="methodInfo">method which TypeMethodInfo is created.</param> /// <returns>Created TypeMethodInfo.</returns> private TypeMethodInfo createMethodInfo(MethodInfo methodInfo) { if (methodInfo == null) { return(null); } return(TypeMethodInfo.Create(methodInfo)); }
/// <summary> /// Create CILMethod from MethodInfo representation. Is used for /// creating methods from runtime .NET methods. /// </summary> /// <param name="method">Runtime .NET method representation.</param> /// <param name="methodInfo">The method information.</param> public CILMethod(MethodInfo method, TypeMethodInfo methodInfo) { //TODO: Reflection methods doesnt support now context generic parameters Context = new TranscriptionContext(methodInfo, new GenericParameter[0]); Name = method.Name; MethodDescription = method.ToString(); var reader = new ILReader(method); Instructions = from instruction in reader.Instructions select new CILInstruction(instruction, Context); }
/// <summary> /// Generate unary info for specified method. /// </summary> /// <param name="methodName">Name of the method.</param> /// <returns>TypeMethodInfo.</returns> private TypeMethodInfo unaryOperatorInfo(string methodName) { var thisInfo = TypeDescriptor.Create <T>(); var op = ParameterTypeInfo.Create("op", thisInfo); var methodInfo = new TypeMethodInfo(thisInfo, methodName, thisInfo, ParameterTypeInfo.NoParams, false, TypeDescriptor.NoDescriptors); return(methodInfo); }
/// <summary> /// Generates the instructions of given method. /// </summary> /// <param name="method">The method.</param> /// <param name="info">The method information.</param> /// <param name="emitter">The emitter where instructions will be generated.</param> /// <param name="services">The services from <see cref="MEFEditor.TypeSystem"/>.</param> public static void GenerateInstructions(CILMethod method, TypeMethodInfo info, EmitterBase emitter, TypeServices services) { Console.WriteLine(method.ToString()); var compiler = new Compiler(method, info, emitter, services); compiler.generateInstructions(); //Console.WriteLine(emitter.GetEmittedInstructions().Code); }
/// <summary> /// Adds the method. /// </summary> /// <param name="method">The method.</param> /// <param name="info">The information.</param> /// <param name="implementedTypes">The implemented types.</param> private void addMethod(GeneratorBase method, TypeMethodInfo info, IEnumerable <InstanceInfo> implementedTypes) { var implemented = implementedTypes.ToArray(); if (!_knownInheritance.ContainsKey(info.DeclaringType)) { _knownInheritance[info.DeclaringType] = TypeDescriptor.ObjectInfo; } _methods.AddItem(new MethodItem(method, info), implemented); }
internal ArgumentIterator(TypeMethodInfo overload, CompilationContext context) { _overload = overload; _context = context; IsValid = true; foreach (var param in overload.Parameters) { _unresolvedParameters.Add(param.Name, param); } }
/// <summary> /// Generate binary info for specified method. /// </summary> /// <param name="methodName">Name of the method.</param> /// <param name="resultInfo">The result information.</param> /// <returns>TypeMethodInfo.</returns> private TypeMethodInfo binaryInfo(string methodName, TypeDescriptor resultInfo) { var thisInfo = TypeDescriptor.Create <T>(); var op1 = ParameterTypeInfo.Create("op1", thisInfo); var op2 = ParameterTypeInfo.Create("op2", thisInfo); var methodInfo = new TypeMethodInfo(thisInfo, methodName, resultInfo, new ParameterTypeInfo[] { op2 }, false, TypeDescriptor.NoDescriptors); return(methodInfo); }
/// <summary> /// Creates <see cref="TypeMethodInfo"/> for given element /// </summary> /// <param name="element">Element which <see cref="TypeMethodInfo"/> is created</param> /// <returns>Created <see cref="TypeMethodInfo"/></returns> protected TypeMethodInfo BuildFrom(CodeClass2 element) { var declaringType = CreateDescriptor(element); var methodInfo = new TypeMethodInfo( declaringType, RequiredName, TypeDescriptor.Void, ParameterTypeInfo.NoParams, false, TypeDescriptor.NoDescriptors, false ); return(methodInfo); }
public TranscriptionContext(TypeMethodInfo methodInfo, IEnumerable <GenericParameter> genericParameters) { var arguments = methodInfo.Path.GenericArgs.ToArray(); var parameters = genericParameters.ToArray(); for (var i = 0; i < parameters.Length; ++i) { var parameterName = parameters[i]; var argument = TypeDescriptor.Create(arguments[i]); TypeHelper.Substitutions[parameterName] = argument; } }
/// <summary> /// Create CILInstruction from Mono.Cecil instruction representation of instruction. /// </summary> /// <param name="instruction">Mono.Cecil representation of instruction.</param> /// <param name="context">The context of transcription.</param> internal CILInstruction(Instruction instruction, TranscriptionContext context) { Address = instruction.Offset; Data = instruction.Operand; OpCode = instruction.OpCode; MethodOperand = CreateMethodInfo(Data as MethodReference, needsDynamicResolving(OpCode), context); BranchAddressOperand = getBranchOffset(Data as Instruction); SetterOperand = createSetter(Data as FieldReference, context); GetterOperand = createGetter(Data as FieldReference, context); TypeOperand = createTypeInfo(Data as TypeReference, context); }
/// <inheritdoc /> public MethodItem Make(PathInfo methodPath, TypeMethodInfo methodDefinition) { var specializedMethod = Activation.Method.MakeGenericMethod(methodPath); var activation = new ParsingActivation(Activation.SourceCode, specializedMethod, Activation.GenericParameters, Activation.Namespaces); activation.NavigationRequested += Activation.OnNavigated; activation.SourceChangeCommited += Activation.OnCommited; var specializedGenerator = new SourceMethodGenerator(activation, _parsingProvider); return(new MethodItem(specializedGenerator, specializedMethod)); }
public SetterLValue(TypeMethodInfo setter, RValueProvider thisObject, IEnumerable <Argument> positionalArguments, CompilationContext context) : base(context) { _setter = setter; _thisObjet = thisObject; //defensive copy _positionArguments = positionalArguments.ToArray(); if (!_setter.IsStatic && thisObject == null) { throw new ArgumentNullException("thisObject"); } }
/// <summary> /// Create CILInstruction from runtime .NET representation of instruction. /// </summary> /// <param name="instruction">Runtime .NET representation of instruction.</param> /// <param name="context">The context of transcription.</param> internal CILInstruction(ILInstruction instruction, TranscriptionContext context) { Address = instruction.Address; Data = instruction.Data; OpCode = OpCodesTable[instruction.OpCode.Name]; MethodOperand = createMethodInfo(Data as MethodInfo); BranchAddressOperand = getBranchOffset(instruction); SetterOperand = createSetter(Data as FieldInfo); GetterOperand = createGetter(Data as FieldInfo); TypeOperand = null; }
/// <summary> /// Build TypeMethodInfo from current info in build properties. /// </summary> /// <returns>Builded type method info.</returns> internal TypeMethodInfo Build() { var result = new TypeMethodInfo( DeclaringType, MethodName, ReturnType, Parameters.ToArray(), IsStatic, TypeArguments.ToArray(), NeedsDynamicResolving ); return(result); }
private GeneratorBase createInitializer(AttributeInfo compositionAttribute, TypeMethodInfo compositionPointInfo) { if (compositionPointInfo.Parameters.Length == 0) { //no arguments are required return(null); } if (compositionPointInfo.Parameters.Length != compositionAttribute.PositionalArgumentsCount) { _assembly.VS.Log.Error("Detected explicit composition point with wrong argument count for {0}", compositionPointInfo.MethodID); } return(new InitializerGenerator(_assembly, compositionAttribute, compositionPointInfo)); }
/// <summary> /// Creates <see cref="TypeMethodInfo" /> for given element. /// </summary> /// <param name="element">Element which <see cref="TypeMethodInfo" /> is created.</param> /// <returns>Created <see cref="TypeMethodInfo" />.</returns> protected TypeMethodInfo BuildFrom(CodeProperty element) { //translate name according to naming conventions of type system var buildGetter = RequiredName.StartsWith(Naming.GetterPrefix); var namePrefix = buildGetter ? Naming.GetterPrefix : Naming.SetterPrefix; var property2 = element as CodeProperty2; var isShared = property2 != null && property2.IsShared; var method = buildGetter ? element.Getter : element.Setter; var isAbstract = method == null || method.MustImplement; var declaringTypeNode = element.DeclaringClass(); var declaringType = CreateDescriptor(declaringTypeNode); var variableType = CreateDescriptor(element.Type); //properties cannot have type arguments var methodTypeArguments = TypeDescriptor.NoDescriptors; TypeDescriptor returnType; ParameterTypeInfo[] parameters; if (buildGetter) { returnType = variableType; parameters = ParameterTypeInfo.NoParams; } else { returnType = TypeDescriptor.Void; parameters = new[] { ParameterTypeInfo.Create("value", variableType) }; } var isIndexer = RequiredName == Naming.IndexerSetter || RequiredName == Naming.IndexerGetter; if (isIndexer) { var indexParameters = CreateParametersInfo(method.Parameters); parameters = indexParameters.Concat(parameters).ToArray(); } var methodInfo = new TypeMethodInfo( declaringType, RequiredName, returnType, parameters, isShared, methodTypeArguments, isAbstract ); return(methodInfo); }
internal CILGenerator(MethodDefinition method, TypeMethodInfo methodInfo, TypeServices services) { if (services == null) { throw new ArgumentNullException("services"); } //method can be null - is used for default implementations /*if(method==null) * throw new ArgumentNullException("method");*/ _method = method; _info = methodInfo; _services = services; }
/// <summary> /// Creates adapter for given method. /// </summary> /// <param name="method">The method.</param> internal void AdapterFor(MethodInfo method) { var paramsInfo = getParametersInfo(method); var methodTypeArguments = getTypeArguments(method); var returnInfo = getReturnType(method); var isAbstract = method.IsAbstract || _declaringDefinition.IsInterface; BuildedMethodInfo = new TypeMethodInfo( _declaringDefinition.TypeInfo, _methodName, returnInfo, paramsInfo, method.IsStatic, methodTypeArguments, isAbstract); Adapter = generateAdapter(method); }
public CILGenerator(TypeMethodInfo info, CILMethod source, TypeServices services) { if (info == null) { throw new ArgumentNullException("info"); } if (source == null) { throw new ArgumentNullException("source"); } Source = source; Info = info; _services = services; }