internal static CompileResult CompileAssignment( this EvaluationContextBase context, InspectionContext inspectionContext, string target, string expr, DiagnosticFormatter formatter, out ResultProperties resultProperties, out string error, out ImmutableArray <AssemblyIdentity> missingAssemblyIdentities, CultureInfo preferredUICulture, CompilationTestData testData) { var diagnostics = DiagnosticBag.GetInstance(); var result = context.CompileAssignment(inspectionContext, target, expr, diagnostics, out resultProperties, testData); if (diagnostics.HasAnyErrors()) { bool useReferencedModulesOnly; error = context.GetErrorMessageAndMissingAssemblyIdentities(diagnostics, formatter, preferredUICulture, out useReferencedModulesOnly, out missingAssemblyIdentities); } else { error = null; missingAssemblyIdentities = ImmutableArray <AssemblyIdentity> .Empty; } diagnostics.Free(); return(result); }
internal abstract CompileResult CompileAssignment( InspectionContext inspectionContext, string target, string expr, DiagnosticBag diagnostics, out ResultProperties resultProperties, CompilationTestData testData);
internal abstract CompileResult CompileExpression( InspectionContext inspectionContext, string expr, DkmEvaluationFlags compilationFlags, DiagnosticBag diagnostics, out ResultProperties resultProperties, CompilationTestData testData);
/// <summary> /// Compile C# expression and emit assembly with evaluation method. /// </summary> /// <returns> /// Result containing generated assembly, type and method names, and any format specifiers. /// </returns> internal CompileResult CompileExpression( InspectionContext inspectionContext, string expr, DkmEvaluationFlags compilationFlags, DiagnosticFormatter formatter, out ResultProperties resultProperties, out string error, out ImmutableArray<AssemblyIdentity> missingAssemblyIdentities, CultureInfo preferredUICulture, CompilationTestData testData) { var diagnostics = DiagnosticBag.GetInstance(); var result = this.CompileExpression(inspectionContext, expr, compilationFlags, diagnostics, out resultProperties, testData); if (diagnostics.HasAnyErrors()) { bool useReferencedModulesOnly; error = GetErrorMessageAndMissingAssemblyIdentities(diagnostics, formatter, preferredUICulture, out useReferencedModulesOnly, out missingAssemblyIdentities); } else { error = null; missingAssemblyIdentities = ImmutableArray<AssemblyIdentity>.Empty; } diagnostics.Free(); return result; }
internal abstract CompileResult CompileAssignment( InspectionContext inspectionContext, string target, string expr, DiagnosticFormatter formatter, out ResultProperties resultProperties, out string error, out ImmutableArray <AssemblyIdentity> missingAssemblyIdentities, CultureInfo preferredUICulture, CompilationTestData testData);
internal abstract CompileResult CompileAssignment( InspectionContext inspectionContext, string target, string expr, DiagnosticFormatter formatter, out ResultProperties resultProperties, out string error, out ImmutableArray<AssemblyIdentity> missingAssemblyIdentities, CultureInfo preferredUICulture, CompilationTestData testData);
internal PlaceholderLocalBinder( InspectionContext inspectionContext, TypeNameDecoder<PEModuleSymbol, TypeSymbol> typeNameDecoder, CSharpSyntaxNode syntax, MethodSymbol containingMethod, Binder next) : base(next) { _inspectionContext = inspectionContext; _typeNameDecoder = typeNameDecoder; _syntax = syntax; _containingMethod = containingMethod; }
internal static string GetTypeName(InspectionContext context, PseudoVariableKind kind, string id, int index) { switch (kind) { case PseudoVariableKind.Exception: return context.GetExceptionTypeName(); case PseudoVariableKind.StowedException: return context.GetStowedExceptionTypeName(); case PseudoVariableKind.ReturnValue: return context.GetReturnValueTypeName(index); case PseudoVariableKind.ObjectId: case PseudoVariableKind.DeclaredLocal: return context.GetObjectTypeNameById(id); default: throw ExceptionUtilities.UnexpectedValue(kind); } }
internal static string GetTypeName(InspectionContext context, AliasKind kind, string id, int index) { switch (kind) { case AliasKind.Exception: return(context.GetExceptionTypeName()); case AliasKind.StowedException: return(context.GetStowedExceptionTypeName()); case AliasKind.ReturnValue: return(context.GetReturnValueTypeName(index)); case AliasKind.ObjectId: case AliasKind.DeclaredLocal: return(context.GetObjectTypeNameById(id)); default: throw ExceptionUtilities.UnexpectedValue(kind); } }
internal override CompileResult CompileAssignment( InspectionContext inspectionContext, string target, string expr, DiagnosticBag diagnostics, out ResultProperties resultProperties, Microsoft.CodeAnalysis.CodeGen.CompilationTestData testData) { var assignment = target.ParseAssignment(expr, diagnostics); if (assignment == null) { resultProperties = default(ResultProperties); return null; } var context = this.CreateCompilationContext(assignment); ResultProperties properties; var moduleBuilder = context.CompileAssignment(inspectionContext, TypeName, MethodName, testData, diagnostics, out properties); if (moduleBuilder == null) { resultProperties = default(ResultProperties); return null; } using (var stream = new MemoryStream()) { Cci.PeWriter.WritePeToStream( new EmitContext((Cci.IModule)moduleBuilder, null, diagnostics), context.MessageProvider, () => stream, nativePdbWriterOpt: null, pdbPathOpt: null, allowMissingMethodBodies: false, deterministic: false, cancellationToken: default(CancellationToken)); if (diagnostics.HasAnyErrors()) { resultProperties = default(ResultProperties); return null; } resultProperties = properties; return new CSharpCompileResult( stream.ToArray(), GetSynthesizedMethod(moduleBuilder), formatSpecifiers: null); } }
internal override CompileResult CompileAssignment( InspectionContext inspectionContext, string target, string expr, DiagnosticFormatter formatter, out ResultProperties resultProperties, out string error, out ImmutableArray<AssemblyIdentity> missingAssemblyIdentities, System.Globalization.CultureInfo preferredUICulture, Microsoft.CodeAnalysis.CodeGen.CompilationTestData testData) { var diagnostics = DiagnosticBag.GetInstance(); try { var assignment = target.ParseAssignment(expr, diagnostics); if (assignment == null) { error = GetErrorMessageAndMissingAssemblyIdentities(diagnostics, formatter, preferredUICulture, out missingAssemblyIdentities); resultProperties = default(ResultProperties); return default(CompileResult); } var context = this.CreateCompilationContext(assignment); ResultProperties properties; var moduleBuilder = context.CompileAssignment(inspectionContext, TypeName, MethodName, testData, diagnostics, out properties); if (moduleBuilder == null) { error = GetErrorMessageAndMissingAssemblyIdentities(diagnostics, formatter, preferredUICulture, out missingAssemblyIdentities); resultProperties = default(ResultProperties); return default(CompileResult); } using (var stream = new MemoryStream()) { Cci.PeWriter.WritePeToStream( new EmitContext((Cci.IModule)moduleBuilder, null, diagnostics), context.MessageProvider, stream, nativePdbWriterOpt: null, allowMissingMethodBodies: false, deterministic: false, cancellationToken: default(CancellationToken)); if (diagnostics.HasAnyErrors()) { error = GetErrorMessageAndMissingAssemblyIdentities(diagnostics, formatter, preferredUICulture, out missingAssemblyIdentities); resultProperties = default(ResultProperties); return default(CompileResult); } resultProperties = properties; error = null; missingAssemblyIdentities = ImmutableArray<AssemblyIdentity>.Empty; return new CompileResult( stream.ToArray(), typeName: TypeName, methodName: MethodName, formatSpecifiers: null); } } finally { diagnostics.Free(); } }
internal CompilationTestData Evaluate( string source, OutputKind outputKind, string methodName, string expr, out ResultProperties resultProperties, out string error, int atLineNumber = -1, InspectionContext inspectionContext = null, bool includeSymbols = true) { var compilation0 = CreateCompilationWithMscorlib( source, options: (outputKind == OutputKind.DynamicallyLinkedLibrary) ? TestOptions.DebugDll : TestOptions.DebugExe); var runtime = CreateRuntimeInstance(compilation0, includeSymbols); var context = CreateMethodContext(runtime, methodName, atLineNumber); var testData = new CompilationTestData(); ImmutableArray<AssemblyIdentity> missingAssemblyIdentities; var result = context.CompileExpression( inspectionContext ?? DefaultInspectionContext.Instance, expr, DkmEvaluationFlags.TreatAsExpression, DiagnosticFormatter.Instance, out resultProperties, out error, out missingAssemblyIdentities, EnsureEnglishUICulture.PreferredOrNull, testData); Assert.Empty(missingAssemblyIdentities); return testData; }
private static Binder ExtendBinderChain( InspectionContext inspectionContext, CSharpCompilation compilation, MetadataDecoder metadataDecoder, CSharpSyntaxNode syntax, EEMethodSymbol method, Binder binder, bool hasDisplayClassThis, bool methodNotType) { var substitutedSourceMethod = GetSubstitutedSourceMethod(method.SubstitutedSourceMethod, hasDisplayClassThis); var substitutedSourceType = substitutedSourceMethod.ContainingType; var stack = ArrayBuilder<NamedTypeSymbol>.GetInstance(); for (var type = substitutedSourceType; (object)type != null; type = type.ContainingType) { stack.Add(type); } while (stack.Count > 0) { substitutedSourceType = stack.Pop(); binder = new InContainerBinder(substitutedSourceType, binder); if (substitutedSourceType.Arity > 0) { binder = new WithTypeArgumentsBinder(substitutedSourceType.TypeArguments, binder); } } stack.Free(); if (substitutedSourceMethod.Arity > 0) { binder = new WithTypeArgumentsBinder(substitutedSourceMethod.TypeArguments, binder); } if (methodNotType) { // Method locals and parameters shadow pseudo-variables. binder = new PlaceholderLocalBinder(inspectionContext, new EETypeNameDecoder(compilation, metadataDecoder.ModuleSymbol), syntax, method, binder); } binder = new EEMethodBinder(method, substitutedSourceMethod, binder); if (methodNotType) { binder = new SimpleLocalScopeBinder(method.LocalsForBinding, binder); } return binder; }
internal CommonPEModuleBuilder CompileAssignment( InspectionContext inspectionContext, string typeName, string methodName, Microsoft.CodeAnalysis.CodeGen.CompilationTestData testData, DiagnosticBag diagnostics, out ResultProperties resultProperties) { Debug.Assert(inspectionContext != null); var objectType = this.Compilation.GetSpecialType(SpecialType.System_Object); var synthesizedType = new EENamedTypeSymbol( Compilation.SourceModule.GlobalNamespace, objectType, _syntax, _currentFrame, typeName, methodName, this, (method, diags) => { var hasDisplayClassThis = _displayClassVariables.ContainsKey(GeneratedNames.ThisProxyFieldName()); var binder = ExtendBinderChain( inspectionContext, this.Compilation, _metadataDecoder, _syntax, method, this.NamespaceBinder, hasDisplayClassThis, methodNotType: true); return BindAssignment(binder, (ExpressionSyntax)_syntax, diags); }); var module = CreateModuleBuilder( this.Compilation, synthesizedType.Methods, additionalTypes: ImmutableArray.Create((NamedTypeSymbol)synthesizedType), testData: testData, diagnostics: diagnostics); Debug.Assert(module != null); this.Compilation.Compile( module, win32Resources: null, xmlDocStream: null, generateDebugInfo: false, diagnostics: diagnostics, filterOpt: null, cancellationToken: CancellationToken.None); if (diagnostics.HasAnyErrors()) { resultProperties = default(ResultProperties); return null; } // Should be no name mangling since the caller provided explicit names. Debug.Assert(synthesizedType.MetadataName == typeName); Debug.Assert(synthesizedType.GetMembers()[0].MetadataName == methodName); resultProperties = new ResultProperties(DkmClrCompilationResultFlags.PotentialSideEffect); return module; }