void CanFindThing(string code, Func <ClassDeclaration, bool> classFinder, Func <FunctionDeclaration, bool> funcFinder, Func <TLFunction, bool> tlVerifier) { CustomSwiftCompiler compiler = Utils.CompileSwift(code, moduleName: "CanFind"); var errors = new ErrorHandling(); ModuleInventory mi = ModuleInventory.FromFile(Path.Combine(compiler.DirectoryPath, "libCanFind.dylib"), errors); ModuleDeclaration mod = compiler.ReflectToModules(new string [] { compiler.DirectoryPath }, new string [] { compiler.DirectoryPath }, null, "CanFind") [0]; ClassDeclaration classDecl = mod.AllClasses.FirstOrDefault(classFinder); Assert.IsNotNull(classDecl, "nominal type not found"); FunctionDeclaration funcDecl = classDecl.AllMethodsNoCDTor().FirstOrDefault(funcFinder); Assert.IsNotNull(funcDecl, "func decl not found"); // see the note in the implementation of CanFindThing above TLFunction func = XmlToTLFunctionMapper.ToTLFunction(funcDecl, mi, null); Assert.IsNotNull(func, "TLFunction not found"); Assert.IsTrue(tlVerifier(func), "verifier failed"); }
public TypeSpecificationFolderTreeNode( ModuleDeclaration module ) : base( TreeViewImage.Folder, null ) { this.module = module; this.Text = "Type Constructions"; this.EnableLatePopulate(); }
public ExternalFoldersTreeNode(ModuleDeclaration module) : base(TreeViewImage.Folder, null) { this.module = module; this.Text = "References"; this.EnableLatePopulate(); }
public PropertyNotificationAssets(ModuleDeclaration module) { if (module == null) throw new ArgumentNullException("module"); Contract.EndContractBlock(); //INotifyPropertyChanged Related INotifyPropertyChangedTypeSignature = module.FindType(typeof(INotifyPropertyChanged)); PropertyChangedEventHandlerTypeSignature = module.FindType(typeof(INotifyPropertyChanged).GetEvent("PropertyChanged").EventHandlerType); PropertyChangedEventHandlerInvokeMethod = module.FindMethod(PropertyChangedEventHandlerTypeSignature, "Invoke"); PropertyChangedEventArgsTypeSignature = module.FindType(typeof(PropertyChangedEventArgs)); PropertyChangedEventArgsConstructor = module.FindMethod(PropertyChangedEventArgsTypeSignature, ".ctor"); //INotifyPropertyChanging Realted INotifyPropertyChangingTypeSignature = module.FindType(typeof(INotifyPropertyChanging)); PropertyChangingEventHandlerTypeSignature = module.FindType(typeof(INotifyPropertyChanging).GetEvent("PropertyChanging").EventHandlerType); PropertyChangingEventHandlerInvokeMethod = module.FindMethod(PropertyChangingEventHandlerTypeSignature, "Invoke"); PropertyChangingEventArgsTypeSignature = module.FindType(typeof(PropertyChangingEventArgs)); PropertyChangingEventArgsConstructor = module.FindMethod(PropertyChangingEventArgsTypeSignature, ".ctor"); }
public ExternalFoldersTreeNode( ModuleDeclaration module ) : base( TreeViewImage.Folder, null ) { this.module = module; this.Text = "References"; this.EnableLatePopulate(); }
public void Visit(ModuleDeclaration node) { if (node != null && node.Binding != null) { m_bindings.Add(node.Binding); } }
public TypeSpecificationFolderTreeNode(ModuleDeclaration module) : base(TreeViewImage.Folder, null) { this.module = module; this.Text = "Type Constructions"; this.EnableLatePopulate(); }
public static AssemblyLoaderInfo LoadAssemblyLoader(bool createTemporaryAssemblies, bool hasUnmanaged, ModuleDeclaration module) { AssemblyLoaderInfo info = new AssemblyLoaderInfo(); TypeDefDeclaration sourceType; if (createTemporaryAssemblies) { sourceType = module.FindType("PostSharp.Community.Packer.Templates.ILTemplateWithTempAssembly") .GetTypeDefinition(); } else if (hasUnmanaged) { sourceType = module.FindType("PostSharp.Community.Packer.Templates.ILTemplateWithUnmanagedHandler") .GetTypeDefinition(); } else { sourceType = module.FindType("PostSharp.Community.Packer.Templates.ILTemplate") .GetTypeDefinition(); } info.AttachMethod = module.FindMethod(sourceType, "Attach").GetMethodDefinition(); info.StaticConstructorMethod = module.FindMethod(sourceType, ".cctor").GetMethodDefinition(); info.AssemblyNamesField = sourceType.FindField("assemblyNames")?.Field; info.SymbolNamesField = sourceType.FindField("symbolNames")?.Field; info.PreloadListField = sourceType.FindField("preloadList")?.Field; info.Preload32ListField = sourceType.FindField("preload32List")?.Field; info.Preload64ListField = sourceType.FindField("preload64List")?.Field; info.Md5HashField = sourceType.FindField("md5Hash")?.Field; info.ChecksumsField = sourceType.FindField("checksums")?.Field; return(info); }
public void OptionalSmokeTest1() { string code = "public func optInt(x:Int) -> Int? { if (x >= 0) { return x; }\nreturn nil; }\n"; ModuleDeclaration module = ReflectToModules(code, "SomeModule").Find(m => m.Name == "SomeModule"); Assert.IsNotNull(module); }
public void FindsPropertyGetterAndSetterFuncs() { string code = "public class Bar { public var x:Int = 0; }"; CustomSwiftCompiler compiler = Utils.CompileSwift(code, moduleName: "CanFind"); ModuleDeclaration mod = compiler.ReflectToModules(new string [] { compiler.DirectoryPath }, new string [] { compiler.DirectoryPath }, null, "CanFind") [0]; ClassDeclaration classDecl = mod.AllClasses.FirstOrDefault(cl => cl.Name == "Bar"); Assert.IsNotNull(classDecl); PropertyDeclaration propDecl = classDecl.Members.OfType <PropertyDeclaration> ().FirstOrDefault(p => p.Name == "x"); Assert.IsNotNull(propDecl); FunctionDeclaration getter = propDecl.GetGetter(); Assert.IsNotNull(getter); FunctionDeclaration setter = propDecl.GetSetter(); Assert.IsNotNull(setter); }
public PostEdgeWeaverAssets(ModuleDeclaration module) { if (module == null) throw new ArgumentNullException("module"); _module = module; _delegateCombineMethod = new Lazy<IMethod>(() => { var method = _module.FindMethod("System.Delegate, mscorlib", "Combine", "System.Delegate, mscorlib","System.Delegate, mscorlib"); Debug.Assert(method != null, "Could not find Delegate.Combine used by PostEdgeWeaverAssets."); return method; }); _delegateRemoveMethod = new Lazy<IMethod>(() => { var method = _module.FindMethod("System.Delegate, mscorlib", "Remove", "System.Delegate, mscorlib", "System.Delegate, mscorlib"); Debug.Assert(method != null, "Could not find Delegate.Remove used by PostEdgeWeaverAssets."); return method; }); _compareExchangeMethod = new Lazy<IMethod>(() => { var method = _module.FindMethod("System.Threading.Interlocked, mscorlib", "CompareExchange", methodDef => methodDef.IsGenericDefinition); Debug.Assert(method != null, "System.Threading.Interlocked.CompareExchange used by PostEdgeWeaverAssets."); return method; }); }
private void convertComputationUnit(CompilationUnitSyntax compilationUnit, ModuleDeclaration module) { foreach (var memberDeclarationSyntax in compilationUnit.Members) { converMemberDeclaration(memberDeclarationSyntax, module); } }
public StringFormatWriter(ModuleDeclaration module) { this.module = module; ITypeSignature stringType = module.Cache.GetType(typeof(string)); this.format1Method = module.FindMethod(stringType, "Format", method => method.Parameters.Count == 2 && IntrinsicTypeSignature.Is(method.Parameters[0].ParameterType, IntrinsicType.String) && IntrinsicTypeSignature.Is(method.Parameters[1].ParameterType, IntrinsicType.Object)); this.format2Method = module.FindMethod(stringType, "Format", method => method.Parameters.Count == 3 && IntrinsicTypeSignature.Is(method.Parameters[0].ParameterType, IntrinsicType.String) && IntrinsicTypeSignature.Is(method.Parameters[1].ParameterType, IntrinsicType.Object) && IntrinsicTypeSignature.Is(method.Parameters[2].ParameterType, IntrinsicType.Object)); this.format3Method = module.FindMethod(stringType, "Format", method => method.Parameters.Count == 4 && IntrinsicTypeSignature.Is(method.Parameters[0].ParameterType, IntrinsicType.String) && IntrinsicTypeSignature.Is(method.Parameters[1].ParameterType, IntrinsicType.Object) && IntrinsicTypeSignature.Is(method.Parameters[2].ParameterType, IntrinsicType.Object) && IntrinsicTypeSignature.Is(method.Parameters[3].ParameterType, IntrinsicType.Object)); this.formatArrayMethod = module.FindMethod(stringType, "Format", method => method.Parameters.Count == 2 && IntrinsicTypeSignature.Is(method.Parameters[0].ParameterType, IntrinsicType.String) && method.Parameters[1].ParameterType.BelongsToClassification(TypeClassifications.Array)); }
private void ProcessModuleProperty(TypeScriptContext tsc, ModuleDeclaration md, HtmlNode h, string sn) { var div = h.ParentNode; var typeText = div.SelectSingleNode("*[@class='type-signature']")?.InnerText.Trim(); var vd = new VariableDeclaration() { IsConstant = div.SelectSingleNode("div/span[@class='label label-constant']") != null, Name = sn, VariableType = string.IsNullOrEmpty(typeText) ? BuiltinType.Any : ResolveType(tsc, typeText).Type }; var dsc = div.SelectNodes("p[not(@class)]").SanitizeDocumentation(); if (dsc != null) { vd.Documentation = new Documentation() { Summary = dsc }; } md.Statements.Add(vd); StatementParsed?.Invoke(this, new StatementEventArgs(vd)); }
void FindsProperty(string code, Func <ClassDeclaration, bool> classFinder, Func <PropertyDeclaration, bool> propFinder) { CustomSwiftCompiler compiler = Utils.CompileSwift(code, moduleName: "CanFind"); var errors = new ErrorHandling(); ModuleInventory mi = ModuleInventory.FromFile(Path.Combine(compiler.DirectoryPath, "libCanFind.dylib"), errors); ModuleDeclaration mod = compiler.ReflectToModules(new string [] { compiler.DirectoryPath }, new string [] { compiler.DirectoryPath }, null, "CanFind") [0]; ClassDeclaration classDecl = mod.AllClasses.FirstOrDefault(classFinder); Assert.IsNotNull(classDecl, "null class"); PropertyDeclaration propDecl = classDecl.Members.OfType <PropertyDeclaration> ().FirstOrDefault(propFinder); Assert.IsNotNull(propDecl, "null property"); FunctionDeclaration getter = propDecl.GetGetter(); Assert.IsNotNull(getter, "null getter"); FunctionDeclaration setter = propDecl.GetSetter(); Assert.IsNotNull(setter, "null setter"); TLFunction tlgetter = XmlToTLFunctionMapper.ToTLFunction(getter, mi); Assert.IsNotNull(tlgetter, "null tlgetter"); TLFunction tlsetter = XmlToTLFunctionMapper.ToTLFunction(setter, mi); Assert.IsNotNull(tlsetter, "null tlsetter"); }
public void RoundTripStruct() { ModuleDeclaration module = ReflectToModules("public struct Foo {\npublic var x:Int\n } ", "SomeModule").Find(m => m.Name == "SomeModule"); StructDeclaration fooClass = module.AllStructs.Where(cl => cl.Name == "Foo").FirstOrDefault(); Assert.IsNotNull(fooClass); StructDeclaration unrootedFoo = fooClass.MakeUnrooted() as StructDeclaration; Entity entity = new Entity { SharpNamespace = "SomeModule", SharpTypeName = "Foo", Type = unrootedFoo }; TypeDatabase db = new TypeDatabase(); db.Add(entity); MemoryStream ostm = new MemoryStream(); db.Write(ostm, "SomeModule"); ostm.Seek(0, SeekOrigin.Begin); TypeDatabase dbread = new TypeDatabase(); var errors = dbread.Read(ostm); Utils.CheckErrors(errors); Entity entityRead = dbread.EntityForSwiftName("SomeModule.Foo"); Assert.IsNotNull(entityRead); Assert.AreEqual(entity.SharpNamespace, entityRead.SharpNamespace); Assert.AreEqual(entity.SharpTypeName, entityRead.SharpTypeName); Assert.IsTrue(entity.Type is StructDeclaration); }
public void Initialize(ModuleDeclaration module) { this.loggingImplementation = new LoggingImplementationTypeBuilder(module); this.formatWriter = new StringFormatWriter(module); this.loggerType = module.FindType(typeof(Logger)); Predicate <MethodDefDeclaration> singleMessagePredicate = method => method.Parameters.Count == 1 && IntrinsicTypeSignature.Is(method.Parameters[0].ParameterType, IntrinsicType.String); this.categoryInitializerMethod = module.FindMethod(module.FindType(typeof(LogManager)), "GetLogger", singleMessagePredicate); this.writeDebugMethod = module.FindMethod(this.loggerType, "Trace", singleMessagePredicate); this.writeInfoMethod = module.FindMethod(this.loggerType, "Info", singleMessagePredicate); this.writeWarnMethod = module.FindMethod(this.loggerType, "Warn", singleMessagePredicate); this.writeErrorMethod = module.FindMethod(this.loggerType, "Error", singleMessagePredicate); this.writeFatalMethod = module.FindMethod(this.loggerType, "Fatal", singleMessagePredicate); this.getIsTraceEnabledMethod = module.FindMethod(this.loggerType, "get_IsTraceEnabled"); this.getIsInfoEnabledMethod = module.FindMethod(this.loggerType, "get_IsInfoEnabled"); this.getIsWarnEnabledMethod = module.FindMethod(this.loggerType, "get_IsWarnEnabled"); this.getIsErrorEnabledMethod = module.FindMethod(this.loggerType, "get_IsErrorEnabled"); this.getIsFatalEnabledMethod = module.FindMethod(this.loggerType, "get_IsFatalEnabled"); }
public void Initialize(ModuleDeclaration module) { this.loggingImplementation = new LoggingImplementationTypeBuilder(module); this.formatWriter = new StringFormatWriter(module); this.loggerType = module.FindType(typeof(Logger)); Predicate<MethodDefDeclaration> singleMessagePredicate = method => method.Parameters.Count == 1 && IntrinsicTypeSignature.Is(method.Parameters[0].ParameterType, IntrinsicType.String); this.categoryInitializerMethod = module.FindMethod(module.FindType(typeof(LogManager)), "GetLogger", singleMessagePredicate); this.writeDebugMethod = module.FindMethod(this.loggerType, "Trace", singleMessagePredicate); this.writeInfoMethod = module.FindMethod(this.loggerType, "Info", singleMessagePredicate); this.writeWarnMethod = module.FindMethod(this.loggerType, "Warn", singleMessagePredicate); this.writeErrorMethod = module.FindMethod(this.loggerType, "Error", singleMessagePredicate); this.writeFatalMethod = module.FindMethod(this.loggerType, "Fatal", singleMessagePredicate); this.getIsTraceEnabledMethod = module.FindMethod(this.loggerType, "get_IsTraceEnabled"); this.getIsInfoEnabledMethod = module.FindMethod(this.loggerType, "get_IsInfoEnabled"); this.getIsWarnEnabledMethod = module.FindMethod(this.loggerType, "get_IsWarnEnabled"); this.getIsErrorEnabledMethod = module.FindMethod(this.loggerType, "get_IsErrorEnabled"); this.getIsFatalEnabledMethod = module.FindMethod(this.loggerType, "get_IsFatalEnabled"); }
public ModuleTreeNode( ModuleDeclaration module, string path ) : base( module, TreeViewImage.Module ) { this.Text = module.Name; this.module = module; this.path = path; this.EnableLatePopulate(); }
public TransformationAssets(ModuleDeclaration module) { ObjectTypeSignature = module.FindType(typeof(object)); ObjectEqualsMethod = module.FindMethod(typeof(object).GetMethod("Equals", new[] { typeof(object), typeof(object) }), BindingOptions.Default); LocationBindingTypeSignature = module.FindType(typeof(LocationBinding<>)); SetValueMethod = module.FindMethod(LocationBindingTypeSignature, "SetValue", x => x.DeclaringType.IsGenericDefinition); GetValueMethod = module.FindMethod(LocationBindingTypeSignature, "GetValue", x => x.DeclaringType.IsGenericDefinition); }
private void converMemberDeclaration(MemberDeclarationSyntax memberDeclarationSyntax, ModuleDeclaration module) { if (memberDeclarationSyntax is ClassDeclarationSyntax classDeclarationSyntax) { convertClassDeclaration(classDeclarationSyntax, module); } }
public ModuleDeclaration Import(Microsoft.CodeAnalysis.CSharp.Syntax.CompilationUnitSyntax compilationUnit) { var module = new ModuleDeclaration(); convertComputationUnit(compilationUnit, module); return(module); }
public void TestModuleDeclaration() { ModuleDeclaration node = new ModuleDeclaration(GetSymbolAtom(), new List <Declaration> { GetVarDeclaration() }, Declaration.DeclarationFlags.Export, DefaultLineInfo); CheckSerializationRoundTrip(node); }
public ModuleTypesFolderTreeNode(ModuleDeclaration module) : base(module, TreeViewImage.Folder) { this.Text = "Types"; this.module = module; this.EnableLatePopulate(); }
public ModuleTreeNode(ModuleDeclaration module, string path) : base(module, TreeViewImage.Module) { this.Text = module.Name; this.module = module; this.path = path; this.EnableLatePopulate(); }
public static IExpression Parse(IEnumerator <TokenData> tokens, IContext parentContext, ref bool done) { if (!tokens.MoveNext()) { done = true; } if (done) { return(null); } var moduleDecl = new ModuleDeclaration(); var token = tokens.Current; #region Identifier var identifiers = (ILocalIdentifierScope) new LocalIdentifierScope(); if (token.Type == Token.IdentifierLiteral) { moduleDecl.Name = ((IIdentifierLiteral)token.Data).Content; identifiers = parentContext.AddModule(moduleDecl); if (!tokens.MoveNext()) { done = true; } if (done) { return(moduleDecl); // fully forward declared } token = tokens.Current; } #endregion #region Body if (token.Type == Token.BlockStartIndentation) { var context = new Context(identifiers, new LocalValueScope()) { Parent = parentContext }; var contentBlock = (BlockLiteral)token.Data; moduleDecl.Block = Parser.ParseBlockWithContext(contentBlock, context); if (!tokens.MoveNext()) { done = true; } if (done) { return(moduleDecl); } } #endregion return(moduleDecl); }
public override void ExitModuleDeclaration(ModuleDeclaration moduleDeclaration) { if (moduleDeclaration.Name == "Native") { var root = moduleDeclaration.NearestAncestorOfType <Root>(); moduleDeclaration.Remove(); root.NativeModule = moduleDeclaration; } }
public void TestEmptyStruct() { ModuleDeclaration module = ReflectToModules("public struct Foo { } ", "SomeModule").Find(m => m.Name == "SomeModule"); Assert.AreEqual(0, module.Classes.Count()); Assert.AreEqual(0, module.Functions.Count()); Assert.AreEqual(1, module.Structs.Count()); Assert.AreEqual("Foo", module.Structs.First().Name); }
public void FuncReturningIntOption() { ModuleDeclaration module = ReflectToModules("public func returnIntOpt()->Int? { return 3; }", "SomeModule") .Find(m => m.Name == "SomeModule"); Assert.NotNull(module); FunctionDeclaration func = module.Functions.FirstOrDefault(f => f.Name == "returnIntOpt"); Assert.AreEqual("Swift.Optional<Swift.Int>", func.ReturnTypeName); }
public void FuncReturningDictionary() { ModuleDeclaration module = ReflectToModules("public func returnDict()->[Int:Float] { return [Int:Float](); }", "SomeModule") .Find(m => m.Name == "SomeModule"); Assert.NotNull(module); FunctionDeclaration func = module.Functions.FirstOrDefault(f => f.Name == "returnDict"); Assert.AreEqual("Swift.Dictionary<Swift.Int, Swift.Float>", func.ReturnTypeName); }
public void FuncReturningTuple() { ModuleDeclaration module = ReflectToModules("public func returnTuple()->(Int,Float) { return (0, 3.0); }", "SomeModule") .Find(m => m.Name == "SomeModule"); Assert.NotNull(module); FunctionDeclaration func = module.Functions.FirstOrDefault(f => f.Name == "returnTuple"); Assert.AreEqual("(Swift.Int, Swift.Float)", func.ReturnTypeName); }
private void ProcessModuleMethod(TypeScriptContext tsc, ModuleDeclaration md, HtmlNode h, string sn) { var div = h.ParentNode; var fd = new FunctionDeclaration(); ProcessFunctionCore(tsc, sn, div, fd); md.Statements.Add(fd); StatementParsed?.Invoke(this, new StatementEventArgs(fd)); }
public static TLFunction ToProtocolFactory(string swiftProxyFactoryName, ModuleDeclaration modDecl, ModuleContents contents, TypeMapper typeMap) { var swiftProxyFunctionDecl = modDecl.TopLevelFunctions.Where(fn => fn.Name == swiftProxyFactoryName).FirstOrDefault(); if (swiftProxyFunctionDecl == null) { return(null); } return(ToTLFunction(swiftProxyFunctionDecl, contents, typeMap)); }
public override IEnumerable <INode> VisitModuleDeclaration(TypescriptParser.ModuleDeclarationContext context) { var moduleDeclaration = new ModuleDeclaration(context, context.identifier().GetText(), base.VisitModuleDeclaration(context)); if (context.EXPORT() != null) { moduleDeclaration.Modifiers.Add(MemberModifier.Export); } yield return(moduleDeclaration); }
public void GlobalBool() { ModuleDeclaration module = ReflectToModules("public var aGlobal:Bool = true", "SomeModule") .Find(m => m.Name == "SomeModule"); Assert.NotNull(module); PropertyDeclaration decl = module.TopLevelProperties.FirstOrDefault(f => f.Name == "aGlobal"); Assert.IsNotNull(decl); }
public void Visit(ModuleDeclaration node) { if (node != null) { // if there is a binding, then we shouldn't have a body so we will // need a terminator. If the binding is null, we will have a body, // but it might be null indicating an empty body; but we'll still output // the {} so we won't need a terminator. DoesRequire = node.Binding != null; } }
public Log4NetCategoryBuilder(Log4NetBackend parent, ModuleDeclaration module, string categoryName) { this.parent = parent; this.module = module; this.loggerField = this.parent.loggingImplementation.GetCategoryField(categoryName, this.parent.loggerType, writer => { writer.EmitInstructionString(OpCodeNumber.Ldstr, categoryName); writer.EmitInstructionMethod(OpCodeNumber.Call, this.parent.categoryInitializerMethod); }); }
public ConsoleCategoryBuilder(ConsoleBackend parent, ModuleDeclaration module) { this.parent = parent; this.module = module; this.writeLineMessage = module.FindMethod( module.Cache.GetType(typeof(System.Console)), "WriteLine", method => method.Parameters.Count == 1 && IntrinsicTypeSignature.Is(method.Parameters[0].ParameterType, IntrinsicType.String)); this.writeLineFormat1 = module.FindMethod( module.Cache.GetType(typeof(System.Console)), "WriteLine", method => method.Parameters.Count == 2 && IntrinsicTypeSignature.Is(method.Parameters[0].ParameterType, IntrinsicType.String) && IntrinsicTypeSignature.Is(method.Parameters[1].ParameterType, IntrinsicType.Object)); this.writeLineFormat2 = module.FindMethod( module.Cache.GetType(typeof(System.Console)), "WriteLine", method => method.Parameters.Count == 3 && IntrinsicTypeSignature.Is(method.Parameters[0].ParameterType, IntrinsicType.String) && IntrinsicTypeSignature.Is(method.Parameters[1].ParameterType, IntrinsicType.Object) && IntrinsicTypeSignature.Is(method.Parameters[2].ParameterType, IntrinsicType.Object)); this.writeLineFormat3 = module.FindMethod( module.Cache.GetType(typeof(System.Console)), "WriteLine", method => method.Parameters.Count == 4 && IntrinsicTypeSignature.Is(method.Parameters[0].ParameterType, IntrinsicType.String) && IntrinsicTypeSignature.Is(method.Parameters[1].ParameterType, IntrinsicType.Object) && IntrinsicTypeSignature.Is(method.Parameters[2].ParameterType, IntrinsicType.Object) && IntrinsicTypeSignature.Is(method.Parameters[3].ParameterType, IntrinsicType.Object)); this.writeLineFormat4 = module.FindMethod( module.Cache.GetType(typeof(System.Console)), "WriteLine", method => method.Parameters.Count == 5 && IntrinsicTypeSignature.Is(method.Parameters[0].ParameterType, IntrinsicType.String) && IntrinsicTypeSignature.Is(method.Parameters[1].ParameterType, IntrinsicType.Object) && IntrinsicTypeSignature.Is(method.Parameters[2].ParameterType, IntrinsicType.Object) && IntrinsicTypeSignature.Is(method.Parameters[3].ParameterType, IntrinsicType.Object) && IntrinsicTypeSignature.Is(method.Parameters[4].ParameterType, IntrinsicType.Object)); this.writeLineFormatArray = module.FindMethod( module.Cache.GetType(typeof(System.Console)), "WriteLine", method => method.Parameters.Count == 2 && IntrinsicTypeSignature.Is(method.Parameters[0].ParameterType, IntrinsicType.String) && method.Parameters[1].ParameterType.BelongsToClassification(TypeClassifications.Array)); }
public void Initialize(ModuleDeclaration module) { this.module = module; this.loggingImplementation = new LoggingImplementationTypeBuilder(module); this.loggerType = module.FindType(typeof(Logger)); LoggerMethodsBuilder builder = new LoggerMethodsBuilder(module, this.loggerType); this.categoryInitializerMethod = module.FindMethod(module.FindType(typeof(LogManager)), "GetLogger", method => method.Parameters.Count == 1 && IntrinsicTypeSignature.Is(method.Parameters[0].ParameterType, IntrinsicType.String) ); this.loggerMethods[LogLevel.Debug] = builder.CreateLoggerMethods("Trace"); this.loggerMethods[LogLevel.Info] = builder.CreateLoggerMethods("Info"); this.loggerMethods[LogLevel.Warning] = builder.CreateLoggerMethods("Warn"); this.loggerMethods[LogLevel.Error] = builder.CreateLoggerMethods("Error"); this.loggerMethods[LogLevel.Fatal] = builder.CreateLoggerMethods("Fatal"); }
public LoggingImplementationTypeBuilder( ModuleDeclaration module ) { this.module = module; this.categoryFields = new Dictionary<string, FieldDefDeclaration>(); this.wrapperMethods = new Dictionary<IMethod, MethodDefDeclaration>(); this.stringFormatArrayMethod = module.FindMethod( module.Cache.GetIntrinsic( IntrinsicType.String ), "Format", method => method.Parameters.Count == 2 && IntrinsicTypeSignature.Is( method.Parameters[0].ParameterType, IntrinsicType.String ) && method.Parameters[1].ParameterType.BelongsToClassification( TypeClassifications.Array ) ); this.traceWriteLineMethod = module.FindMethod( module.Cache.GetType( typeof(System.Diagnostics.Trace) ), "WriteLine", method => method.Parameters.Count == 1 && IntrinsicTypeSignature.Is( method.Parameters[0].ParameterType, IntrinsicType.String ) ); this.weavingHelper = new WeavingHelper( module ); this.implementationType = this.CreateContainingType(); this.isLoggingField = this.CreateIsLoggingField(); }
private IMethod GetLoggerMethod(ModuleDeclaration module) { var systemMethod = interceptedMethod.GetSystemMethod(null, null, BindingOptions.Default); var systemParameters = systemMethod.GetParameters(); var parameterTypes = new Type[systemParameters.Length + 1]; for(int i = 0; i < systemParameters.Length; ++i) { parameterTypes[i] = systemParameters[i].ParameterType; } parameterTypes[systemParameters.Length] = typeof(ILog); var loggerMethod = Log.LoggerType.GetMethod(systemMethod.Name, BindingFlags.Public | BindingFlags.Static, null, parameterTypes, null); if (loggerMethod == null) { throw new InvalidOperationException(string.Format(CultureInfo.InvariantCulture, "There is a bug in CodeOMatic.Validation. The method '{0}' does not exist in the Logger class", interceptedMethod)); } return module.FindMethod(loggerMethod, BindingOptions.Default); }
public void Initialize(ModuleDeclaration module) { this.module = module; this.loggingImplementation = new LoggingImplementationTypeBuilder(module); ITypeSignature traceTypeSignature = module.Cache.GetType(typeof(System.Diagnostics.Trace)); this.writeLineString = module.FindMethod(traceTypeSignature, "WriteLine", method => method.Parameters.Count == 1 && IntrinsicTypeSignature.Is(method.Parameters[0].ParameterType, IntrinsicType.String)); this.traceInfoString = module.FindMethod(traceTypeSignature, "TraceInformation", method => method.Parameters.Count == 1 && IntrinsicTypeSignature.Is(method.Parameters[0].ParameterType, IntrinsicType.String)); this.traceInfoFormat = module.FindMethod(traceTypeSignature, "TraceInformation", method => method.Parameters.Count == 2 && IntrinsicTypeSignature.Is(method.Parameters[0].ParameterType, IntrinsicType.String) && method.Parameters[1].ParameterType.BelongsToClassification(TypeClassifications.Array)); this.traceWarningString = module.FindMethod(traceTypeSignature, "TraceWarning", method => method.Parameters.Count == 1 && IntrinsicTypeSignature.Is(method.Parameters[0].ParameterType, IntrinsicType.String)); this.traceWarningFormat = module.FindMethod(traceTypeSignature, "TraceWarning", method => method.Parameters.Count == 2 && IntrinsicTypeSignature.Is(method.Parameters[0].ParameterType, IntrinsicType.String) && method.Parameters[1].ParameterType.BelongsToClassification(TypeClassifications.Array)); this.traceErrorString = module.FindMethod(traceTypeSignature, "TraceError", method => method.Parameters.Count == 1 && IntrinsicTypeSignature.Is(method.Parameters[0].ParameterType, IntrinsicType.String)); this.traceErrorFormat = module.FindMethod(traceTypeSignature, "TraceError", method => method.Parameters.Count == 2 && IntrinsicTypeSignature.Is(method.Parameters[0].ParameterType, IntrinsicType.String) && method.Parameters[1].ParameterType.BelongsToClassification(TypeClassifications.Array)); }
public LoggerMethodsBuilder(ModuleDeclaration module, ITypeSignature loggerType) { this.module = module; this.loggerType = loggerType; // matches XXX(string) this.objectPredicate = method => method.Parameters.Count == 1 && IntrinsicTypeSignature.Is(method.Parameters[0].ParameterType, IntrinsicType.Object); // matches XXX(string format, object arg) this.format1Predicate = method => method.Parameters.Count == 2 && IntrinsicTypeSignature.Is(method.Parameters[0].ParameterType, IntrinsicType.String) && IntrinsicTypeSignature.Is(method.Parameters[1].ParameterType, IntrinsicType.Object); // matches XXX(string format, object arg0, object arg1) this.format2Predicate = method => method.Parameters.Count == 3 && IntrinsicTypeSignature.Is(method.Parameters[0].ParameterType, IntrinsicType.String) && IntrinsicTypeSignature.Is(method.Parameters[1].ParameterType, IntrinsicType.Object) && IntrinsicTypeSignature.Is(method.Parameters[2].ParameterType, IntrinsicType.Object); // matches XXX(string format, object arg0, object arg1, object arg2) this.format3Predicate = method => method.Parameters.Count == 4 && IntrinsicTypeSignature.Is(method.Parameters[0].ParameterType, IntrinsicType.String) && IntrinsicTypeSignature.Is(method.Parameters[1].ParameterType, IntrinsicType.Object) && IntrinsicTypeSignature.Is(method.Parameters[2].ParameterType, IntrinsicType.Object) && IntrinsicTypeSignature.Is(method.Parameters[3].ParameterType, IntrinsicType.Object); // matches XXX(string format, params object[] args) this.formatArrayPredicate = method => method.Parameters.Count == 2 && IntrinsicTypeSignature.Is(method.Parameters[0].ParameterType, IntrinsicType.String) && method.Parameters[1].ParameterType.BelongsToClassification(TypeClassifications.Array); this.objectExceptionPredicate = method => method.Parameters.Count == 2 && IntrinsicTypeSignature.Is(method.Parameters[0].ParameterType, IntrinsicType.Object) && method.Parameters[1].ParameterType.MatchesReference(module.Cache.GetType(typeof(Exception))); }
public void Initialize(ModuleDeclaration module) { }
private static TransformationAssets GetTransformationAssets(ModuleDeclaration module) { return module.Cache.GetItem(() => new TransformationAssets(module)); }
public void Initialize(ModuleDeclaration module) { this.loggingImplementation = new LoggingImplementationTypeBuilder(module); }
public Assets(ModuleDeclaration module) { this.ToStringMethodSignature = module.FindMethod(module.Cache.GetType(typeof(object)), "ToString"); }
public ExternalAssemblyFolderTreeNode( ModuleDeclaration module ) : base( TreeViewImage.Folder, null ) { this.module = module; this.Text = "External Assemblies"; this.EnableLatePopulate(); }
public ConsoleBackendInstance(ConsoleBackend parent, ModuleDeclaration module) { this.parent = parent; this.module = module; }
public ConsoleBackendInstance(ModuleDeclaration module) { this.module = module; }
public Assets(ModuleDeclaration module) { OnThrow = module.FindMethod(typeof(OnThrowAspectAttribute).GetMethod("OnThrow", new[] { typeof(Exception) }), BindingOptions.Default); Exception = module.FindType(typeof(Exception)); }
public LoggingImplementationTypeBuilder(ModuleDeclaration module) { this.module = module; this.weavingHelper = new WeavingHelper(module); this.containingType = this.CreateContainingType(); }