public void TestStringFieldExpressionsMssql(string expr, string expectedQuery) { Setup(expr); CalcParser.ExpressionContext context = this._calcParser.expression(); DbTranslator translator = new MssqlTranslator(); IMetadataResolver resolver = Substitute.For <IMetadataResolver>(); resolver .GetField(Arg.Any <string>()) .Returns(callinfo => new FieldInfo { Name = callinfo.ArgAt <string>(0), Type = DFM_FIELD_TYPE.DFM_FT_STRING }); QueryVisitor visitor = new QueryVisitor(resolver, translator); string query = visitor.Visit(context); Assert.AreEqual(expectedQuery, query); }
public static bool Inherits(this TypeReference self, string @namespace, string name, IMetadataResolver resolver) { if (@namespace == null) { throw new ArgumentNullException("namespace"); } if (name == null) { throw new ArgumentNullException("name"); } if (self == null) { return(false); } TypeReference current = resolver.Resolve(self); while (current != null) { if (current.Is(@namespace, name)) { return(true); } if (current.Is("System", "Object")) { return(false); } TypeDefinition td = resolver.Resolve(current); if (td == null) { return(false); // could not resolve type } current = td.BaseType; } return(false); }
public TypeNameMapGenerator(IEnumerable <string> assemblies, Action <TraceLevel, string> logger, IMetadataResolver resolver) { if (assemblies == null) { throw new ArgumentNullException("assemblies"); } if (logger == null) { throw new ArgumentNullException(nameof(logger)); } Cache = resolver ?? new TypeDefinitionCache(); Log = logger; var Assemblies = assemblies.ToList(); var rp = new ReaderParameters(); Resolver = new DirectoryAssemblyResolver(Log, loadDebugSymbols: true, loadReaderParameters: rp); foreach (var assembly in Assemblies) { var directory = Path.GetDirectoryName(assembly); if (string.IsNullOrEmpty(directory)) { continue; } if (!Resolver.SearchDirectories.Contains(directory)) { Resolver.SearchDirectories.Add(directory); } } foreach (var assembly in Assemblies) { Resolver.Load(Path.GetFullPath(assembly)); } Scanner = new JavaTypeScanner(Log, Cache) { ErrorOnCustomJavaObject = false, }; Types = Scanner.GetJavaTypes(Assemblies, Resolver); }
public MethodCallExpressionBuilder(IReferenceExpression reference, Expression context, IEnumerable <Expression> arguments, IMetadataResolver metadataResolver) { this.reference = reference; this.context = context; this.arguments = arguments; this.metadataResolver = metadataResolver; }
public virtual void Initialize(LinkContext context, MarkContext markContext) { Context = context; cache = context; }
public Calculator(IMetadataResolver resolver) { this.MetadataResolver = resolver; this._visitor = new CalcVisitor(resolver); }
public MemberReferenceExpressionBuilder(IReferenceExpression expression, Expression context, IMetadataResolver metadataResolver) { this.expression = expression; this.context = context; this.metadataResolver = metadataResolver; }
public Signature(MethodDefinition method, ExportFieldAttribute exportField, IMetadataResolver cache) : this(method.Name, GetJniSignature(method, cache), "__export__", null, null, null) { if (method.HasParameters) { Diagnostic.Error(4205, JavaCallableWrapperGenerator.LookupSource(method), Localization.Resources.JavaCallableWrappers_XA4205); } if (method.ReturnType.MetadataType == MetadataType.Void) { Diagnostic.Error(4208, JavaCallableWrapperGenerator.LookupSource(method), Localization.Resources.JavaCallableWrappers_XA4208); } IsExport = true; IsStatic = method.IsStatic; JavaAccess = JavaCallableWrapperGenerator.GetJavaAccess(method.Attributes & MethodAttributes.MemberAccessMask); // annotations are processed within JavaFieldInfo, not the initializer method. So we don't generate them here. }
public override Expression VisitLambdaExpression(ILambdaExpression lambdaExpressionParam, IMetadataResolver context) { lambdaParameters.AddRange(lambdaExpressionParam.ParameterDeclarations.Select( declaration => declaration.Accept(this, context) as ParameterExpression)); Expression body = lambdaExpressionParam.BodyExpression.Accept(this, context); return(Expression.Lambda <TDelegate>(body, lambdaParameters)); }
public override Expression VisitCSharpLiteralExpression(ICSharpLiteralExpression expression, IMetadataResolver context) { var declaredType = expression.ConstantValue.Type as IDeclaredType; if (declaredType != null) { Type type = Type.GetType(declaredType.GetClrName().FullName); Assertion.Assert(type != null, "type != null"); return(Expression.Constant(expression.ConstantValue.Value, type)); } return(Expression.Constant(expression.ConstantValue.Value)); }
public override Expression VisitUserTypeUsage(IUserTypeUsage userTypeUsageParam, IMetadataResolver context) { return(null); }
public override Expression VisitTypeofExpression(ITypeofExpression typeofExpressionParam, IMetadataResolver context) { IDeclaredType declaredType = typeofExpressionParam.ArgumentType.GetScalarType(); if (declaredType == null || !declaredType.IsValid()) { return(base.VisitTypeofExpression(typeofExpressionParam, context)); } string assemblyName = GetTypeAssemblyFullName(declaredType); #if DEBUG if (string.IsNullOrWhiteSpace(assemblyName)) { Console.WriteLine(assemblyName); } #endif string fullyQualifiedTypeName = string.Format("{0}, {1}", declaredType.GetClrName().FullName, assemblyName); Type value = Type.GetType(fullyQualifiedTypeName); return(Expression.Constant(value, typeof(Type))); }
public override Expression VisitPrimaryExpression(IPrimaryExpression primaryExpressionParam, IMetadataResolver context) { return(null); }
public override Expression VisitEqualityExpression(IEqualityExpression equalityExpressionParam, IMetadataResolver context) { Expression left = equalityExpressionParam.LeftOperand.Accept(this, context); Expression right = equalityExpressionParam.RightOperand.Accept(this, context); return(new EqualityExpressionBuilder(equalityExpressionParam, left, right).Build()); }
public override Expression VisitCSharpArgument(ICSharpArgument cSharpArgumentParam, IMetadataResolver context) { return(cSharpArgumentParam.Value.Accept(this, context)); }
JavaCallableWrapperGenerator(TypeDefinition type, string outerType, Action <string, object[]> log, IMetadataResolver resolver) { this.type = type; this.log = log; this.cache = resolver ?? new TypeDefinitionCache(); if (type.IsEnum || type.IsInterface || type.IsValueType) { Diagnostic.Error(4200, LookupSource(type), Localization.Resources.JavaCallableWrappers_XA4200, type.FullName); } string jniName = JavaNativeTypeManager.ToJniName(type); if (jniName == null) { Diagnostic.Error(4201, LookupSource(type), Localization.Resources.JavaCallableWrappers_XA4201, type.FullName); } if (!string.IsNullOrEmpty(outerType)) { string p; jniName = jniName.Substring(outerType.Length + 1); ExtractJavaNames(outerType, out p, out outerType); } ExtractJavaNames(jniName, out package, out name); if (string.IsNullOrEmpty(package) && (type.IsSubclassOf("Android.App.Activity", cache) || type.IsSubclassOf("Android.App.Application", cache) || type.IsSubclassOf("Android.App.Service", cache) || type.IsSubclassOf("Android.Content.BroadcastReceiver", cache) || type.IsSubclassOf("Android.Content.ContentProvider", cache))) { Diagnostic.Error(4203, LookupSource(type), Localization.Resources.JavaCallableWrappers_XA4203, jniName); } foreach (MethodDefinition minfo in type.Methods.Where(m => !m.IsConstructor)) { var baseRegisteredMethod = GetBaseRegisteredMethod(minfo); if (baseRegisteredMethod != null) { AddMethod(baseRegisteredMethod, minfo); } else if (GetExportFieldAttributes(minfo).Any()) { AddMethod(null, minfo); HasExport = true; } else if (GetExportAttributes(minfo).Any()) { AddMethod(null, minfo); HasExport = true; } } foreach (MethodDefinition imethod in type.Interfaces.Select(ifaceInfo => ifaceInfo.InterfaceType) .Select(r => { var d = r.Resolve(); if (d == null) { Diagnostic.Error(4204, LookupSource(type), Localization.Resources.JavaCallableWrappers_XA4204, r.FullName); } return(d); }) .Where(d => GetRegisterAttributes(d).Any()) .SelectMany(d => d.Methods) .Where(m => !m.IsStatic)) { AddMethod(imethod, imethod); } var ctorTypes = new List <TypeDefinition> () { type, }; foreach (var bt in type.GetBaseTypes(cache)) { ctorTypes.Add(bt); RegisterAttribute rattr = GetRegisterAttributes(bt).FirstOrDefault(); if (rattr != null && rattr.DoNotGenerateAcw) { break; } } ctorTypes.Reverse(); var curCtors = new List <MethodDefinition> (); foreach (MethodDefinition minfo in type.Methods.Where(m => m.IsConstructor)) { if (GetExportAttributes(minfo).Any()) { if (minfo.IsStatic) { // Diagnostic.Warning (log, "ExportAttribute does not work on static constructor"); } else { AddConstructor(minfo, ctorTypes [0], outerType, null, curCtors, false, true); HasExport = true; } } } AddConstructors(ctorTypes [0], outerType, null, curCtors, true); for (int i = 1; i < ctorTypes.Count; ++i) { var baseCtors = curCtors; curCtors = new List <MethodDefinition> (); AddConstructors(ctorTypes [i], outerType, baseCtors, curCtors, false); } }
public JavaCallableWrapperGenerator(TypeDefinition type, Action <string, object[]> log, IMetadataResolver resolver) : this(type, null, log, resolver) { if (type.HasNestedTypes) { children = new List <JavaCallableWrapperGenerator> (); AddNestedTypes(type); } }
public override Expression VisitLambdaParameterDeclaration(ILambdaParameterDeclaration lambdaParameterDeclarationParam, IMetadataResolver context) { return(new ParameterExpressionBuilder(lambdaParameterDeclarationParam, context).Build()); }
public InstanceBuilderServiceProvider(object target, object property, IMetadataResolver metadataResolver) { this.provideValueTarget = new InstanceBuilderOperations.InstanceBuilderServiceProvider.ProvideValueTarget(target, property); this.metadataResolver = metadataResolver; }
public override Expression VisitUnaryOperatorExpression(IUnaryOperatorExpression unaryOperatorExpressionParam, IMetadataResolver context) { Expression operandExpression = unaryOperatorExpressionParam.Operand.Accept(this, context); return(new UnaryOperatorExpressionBuilder(unaryOperatorExpressionParam, operandExpression).Build()); }
public FixAbstractMethodsStep(IMetadataResolver cache) { this.cache = cache; }
public override Expression VisitParenthesizedExpression(IParenthesizedExpression parenthesizedExpressionParam, IMetadataResolver context) { return(parenthesizedExpressionParam.Expression.Accept(this, context)); }
public static bool TryGetBaseOrInterfaceRegisterMember(this MethodDefinition method, IMetadataResolver resolver, out string member, out string nativeMethod, out string signature) { var type = method.DeclaringType; member = nativeMethod = signature = null; if (method.IsConstructor || type == null || !type.HasNestedTypes) { return(false); } var m = method.GetBaseDefinition(resolver); while (m != null) { if (m == method) { break; } method = m; if (m.TryGetRegisterMember(out member, out nativeMethod, out signature)) { return(true); } m = m.GetBaseDefinition(resolver); } if (!method.DeclaringType.HasInterfaces || !method.IsNewSlot) { return(false); } foreach (var iface in method.DeclaringType.Interfaces) { if (iface.InterfaceType.IsGenericInstance) { continue; } var itype = iface.InterfaceType.Resolve(); if (itype == null || !itype.HasMethods) { continue; } foreach (var im in itype.Methods) { if (im.IsEqual(method, resolver)) { return(im.TryGetRegisterMember(out member, out nativeMethod, out signature)); } } } return(false); }
public override Expression VisitBinaryExpression(IBinaryExpression binaryExpressionParam, IMetadataResolver context) { Expression left = binaryExpressionParam.LeftOperand.Accept(this, context); Expression right = binaryExpressionParam.RightOperand.Accept(this, context); return(new BinaryExpressionBuilder(binaryExpressionParam, left, right).Build()); }
internal DllData(string dir, DllConfig config) { _config = config; _dir = dir; AddSearchDirectory(dir); _metadataResolver = new MetadataResolver(this); _readerParams = new ReaderParameters(ReadingMode.Immediate) { AssemblyResolver = this, MetadataResolver = _metadataResolver }; var modules = new List <ModuleDefinition>(); foreach (var file in Directory.GetFiles(dir)) { if (file.EndsWith(".dll") && !_config.BlacklistDlls.Contains(file)) { var assemb = AssemblyDefinition.ReadAssembly(file, _readerParams); foreach (var module in assemb.Modules) { modules.Add(module); } } } Queue <TypeDefinition> frontier = new Queue <TypeDefinition>(); modules.ForEach(m => m.Types.ToList().ForEach(t => { if (_config.ParseTypes && !_config.BlacklistTypes.Contains(t.Name)) { frontier.Enqueue(t); } })); while (frontier.Count > 0) { var t = frontier.Dequeue(); if (t.Name.StartsWith("<") && t.Namespace.Length == 0 && t.DeclaringType is null) { if (!t.Name.StartsWith("<Module>") && !t.Name.StartsWith("<PrivateImplementationDetails>")) { Console.Error.WriteLine($"Skipping TypeDefinition {t}"); } continue; } var dllRef = DllTypeRef.From(t); if (!_types.ContainsKey(dllRef)) { var type = new DllTypeData(t, _config); if (dllRef.DeclaringType != null) { _types[dllRef.DeclaringType].NestedTypes.AddOrThrow(type); } foreach (var nested in t.NestedTypes) { frontier.Enqueue(nested); } _types.Add(dllRef, type); } else { Console.Error.WriteLine($"{dllRef} already in _types! Matching item: {_types[dllRef].This}"); } } int total = DllTypeRef.Hits + DllTypeRef.Misses; Console.WriteLine($"{nameof(DllTypeRef)} cache hits: {DllTypeRef.Hits} / {total} = {100.0f * DllTypeRef.Hits / total}"); // Ignore images for now. }
public override Expression VisitInvocationExpression(IInvocationExpression invocationExpressionParam, IMetadataResolver context) { var result = invocationExpressionParam.InvocationExpressionReference.Resolve().Result; ExtensionInstance <IDeclaredElement> extension = result.ElementAsExtension(); return(invocationExpressionParam.InvokedExpression.Accept(this, context)); }
public TypeNameMapGenerator(IEnumerable <TypeDefinition> types, Action <TraceLevel, string> logger, IMetadataResolver resolver) { if (types == null) { throw new ArgumentNullException("types"); } if (logger == null) { throw new ArgumentNullException(nameof(logger)); } Cache = resolver ?? new TypeDefinitionCache(); Log = logger; Types = types.ToList(); }
public override Expression VisitReferenceExpression(IReferenceExpression referenceExpressionParam, IMetadataResolver context) { if (referenceExpressionParam.QualifierExpression != null) { Expression qualifierExpression = referenceExpressionParam.QualifierExpression.Accept(this, context); var invocationExpression = referenceExpressionParam.Parent as IInvocationExpression; if (invocationExpression != null) { IEnumerable <Expression> arguments = invocationExpression.ArgumentList.Arguments.Select( argument => argument.Accept(this, context)); return(new MethodCallExpressionBuilder(referenceExpressionParam, qualifierExpression, arguments, context).Build()); } return(new MemberReferenceExpressionBuilder(referenceExpressionParam, qualifierExpression, context).Build()); } ResolveResultWithInfo resolve = referenceExpressionParam.Reference.Resolve(); var lambdaParameterDeclaration = resolve.DeclaredElement as ILambdaParameterDeclaration; if (lambdaParameterDeclaration != null) { return(lambdaParameters.First( parameter => parameter.Name.Equals(lambdaParameterDeclaration.NameIdentifier.GetText()))); } var parameterDeclaration = resolve.DeclaredElement as IParameterDeclaration; if (parameterDeclaration != null) { return(new ParameterExpressionBuilder(parameterDeclaration, context).Build()); } return(base.VisitReferenceExpression(referenceExpressionParam, context)); }
public CalcVisitor(IMetadataResolver resolver) { this._resolver = resolver; }
public AddKeepAlivesStep(IMetadataResolver cache) { this.cache = cache; }