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); }
/// <summary> /// Build <see cref="MethodItem" /> from given <see cref="CodeFunction" />. /// </summary> /// <param name="element">Method definition element.</param> /// <returns>Built method.</returns> public MethodItem BuildFrom(CodeFunction element) { var sourceCode = element.MustImplement ? null : GetSourceCode(element); var isCtor = MethodInfo.MethodName == Naming.CtorName; if (isCtor) { //ctor can have precode sourceCode = GetPreCode(element) + sourceCode; } var namespaces = DeclaringAssembly.GetNamespaces(element as CodeElement); //get generic parameters info var fullname = element.FullName; var genericPath = new PathInfo(fullname); var activation = new ParsingActivation(sourceCode, MethodInfo, genericPath.GenericArgs, namespaces); RegisterActivation(activation, element as CodeElement); var generator = new SourceMethodGenerator(activation, DeclaringAssembly.ParsingProvider); var item = new MethodItem(generator, MethodInfo); return(item); }
/// <inheritdoc /> public override void ParsingProvider(ParsingActivation activation, EmitterBase emitter) { var w = Stopwatch.StartNew(); var source = Compiler.GenerateInstructions(activation, emitter, TypeServices); var methodID = activation.Method == null ? new MethodID("$inline", false) : activation.Method.MethodID; VS.Log.Message("Parsing time for {0} {1}ms", methodID, w.ElapsedMilliseconds); }
/// <summary> /// Build implicit ctor or initializer method from given source. /// </summary> /// <param name="element">Element which method is built.</param> /// <param name="sourceCode">Code of method.</param> /// <returns>Built method.</returns> private MethodItem buildFromSource(CodeClass2 element, string sourceCode) { var namespaces = DeclaringAssembly.GetNamespaces(element as CodeElement); var activation = new ParsingActivation(sourceCode, MethodInfo, new string[0], namespaces); RegisterActivation(activation, element as CodeElement); var generator = new SourceMethodGenerator(activation, DeclaringAssembly.ParsingProvider); return(new MethodItem(generator, MethodInfo)); }
/// <summary> /// Register handlers on activation for purposes of binding with source. /// </summary> /// <param name="activation">Activation which bindings will be registered.</param> /// <param name="element">Element where bindings will be applied.</param> protected void RegisterActivation(ParsingActivation activation, CodeElement element) { var fn = element as CodeFunction; if (fn != null) { activation.SourceChangeCommited += (source, ns) => { Write(fn, source, ns); } } ; activation.NavigationRequested += (offset) => Navigate(element, offset); }
/// <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)); }
/// <summary> /// Initialize <see cref="SourceMethodGenerator"/> object from given activation. /// </summary> /// <param name="activation">Activation of parser for generated method</param> /// <param name="parsingProvider">Provider of parsing service for method</param> internal SourceMethodGenerator(ParsingActivation activation, ParsingProvider parsingProvider) { if (parsingProvider == null) { throw new ArgumentNullException("parsingProvider"); } if (activation == null) { throw new ArgumentNullException("activation"); } _parsingProvider = parsingProvider; Activation = activation; }
protected override void generate(EmitterBase emitter) { var activation = new ParsingActivation(SourceCode, Method, _genericParameters); Source = Compiler.GenerateInstructions(activation, emitter, _services); }