/// <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;
}
