public TypeInfo GetTypeInfo(Type type)
{
if (!_typeInfos.ContainsKey(type))
{
var typeInfo = new TypeInfo
{
Id = _typeInfos.Count,
TypeName = type.AssemblyQualifiedName,
IsEnumerable = type.IsImplOf<IEnumerable>()
};
if (!typeInfo.IsEnumerable)
{
var propertyInfos = type.GetProperties();
var propertyNames = new SimpleList<string>();
foreach (var propertyInfo in propertyInfos)
{
if (!IsAValidProperty(propertyInfo)) continue;
propertyNames.Add(propertyInfo.Name);
}
typeInfo.PropertyNames = propertyNames;
}
_typeInfos.Add(type, typeInfo);
return typeInfo;
}
return _typeInfos[type];
}
internal static TypeInfo GetNextTypeInfo(Type initialArg, TypeInfo curTypeInfo)
{
lock (_DelegateCache)
{
return NextTypeInfo(initialArg, curTypeInfo);
}
}
public static void TypeInfo_BaseType(TypeInfo typeInfo)
{
String typeName = typeInfo.NameString();
if (typeName == null)
return;
ReflectionEventSource.Log.TypeInfo_BaseType(typeName);
}
static void setBoxing(CompilerContext context, TypeInfo targetType, ExpressionNode expression) {
var info = expression.getUserData(typeof(ExpressionInfo));
if (info == null || targetType == null) {
return;
}
var type = getType(context, expression);
if (type == targetType) {
return;
}
if (isAssignable(context, targetType, expression)) {
if (targetType.IsPrimitive) {
if (!type.IsPrimitive) {
info.BoxingKind = BoxingKind.Unbox;
var unboxinMethod = context.TypeSystem.getUnboxingMethod(type);
info.BoxingMethod = unboxinMethod;
info.OriginalType = info.Type;
info.Type = unboxinMethod.ReturnType;
}
} else if (type.IsPrimitive) {
info.BoxingKind = BoxingKind.Box;
var boxingMethod = context.TypeSystem.getBoxingMethod((targetType.IsObject) ? type : targetType);
info.BoxingMethod = boxingMethod;
info.OriginalType = info.Type;
info.Type = boxingMethod.ReturnType;
} else if (targetType.IsNumeric && type.IsNumeric) {
info.BoxingKind = BoxingKind.Unbox;
info.BoxingMethod = context.TypeSystem.getUnboxingMethod(type);
}
}
}
public override FlatOperand Resolve(ExpressionSyntax expression, ArgumentListSyntax argumentList, TypeInfo result_type, SymbolInfo si, FlatOperand into_lvalue, Function function, List<FlatStatement> instructions)
{
FlatOperand fop_subject;
if (expression is IdentifierNameSyntax)
{
// typeof this
fop_subject = FlatOperand.ThisRef(FlatValue.FromType(result_type.ConvertedType));
}
else if (expression is MemberAccessExpressionSyntax)
{
MemberAccessExpressionSyntax meas = (MemberAccessExpressionSyntax)expression;
fop_subject = function.ResolveExpression(meas.Expression, null, instructions);
}
else
{
throw new NotImplementedException("GetMetaTable on expression type " + expression.GetType().ToString());
}
if (into_lvalue == null)
{
FlatOperand fop_register = function.AllocateRegister("");
into_lvalue = fop_register.GetLValue(function, instructions);
}
instructions.Add(FlatStatement.GETMETATABLE(into_lvalue, fop_subject));
return into_lvalue.AsRValue(FlatValue.Table());
}
public void It_detects_Obsolete_attributes()
{
var typeInfo = new TypeInfo();
typeInfo.ReadType(Compiler.GetType(
@"namespace MyNamespace
{
[System.Obsolete(""This class is obsolete!"")]
public class MyClass
{
[System.Obsolete(""This constructor is obsolete!"")]
public MyClass() { }
[System.Obsolete(""This method is obsolete!"")]
public void MyMethod() { }
[System.Obsolete(""This property is obsolete!"")]
public int MyProperty { get; set; }
[System.Obsolete(""This event is obsolete!"")]
public event System.EventHandler MyEvent;
[System.Obsolete(""This field is obsolete!"")]
public int MyField;
}
}"));
Assert.IsTrue(typeInfo.Obsolete);
Assert.AreEqual("This class is obsolete!", typeInfo.ObsoleteMessage);
Assert.IsTrue(typeInfo.Members.Single(m => m.Name == ".ctor").Obsolete);
Assert.AreEqual("This constructor is obsolete!", typeInfo.Members.Single(m => m.Name == ".ctor").ObsoleteMessage);
Assert.IsTrue(typeInfo.Members.Single(m => m.Name == "MyMethod").Obsolete);
Assert.AreEqual("This method is obsolete!", typeInfo.Members.Single(m => m.Name == "MyMethod").ObsoleteMessage);
Assert.IsTrue(typeInfo.Members.Single(m => m.Name == "MyProperty").Obsolete);
Assert.AreEqual("This property is obsolete!", typeInfo.Members.Single(m => m.Name == "MyProperty").ObsoleteMessage);
Assert.IsTrue(typeInfo.Members.Single(m => m.Name == "MyEvent").Obsolete);
Assert.AreEqual("This event is obsolete!", typeInfo.Members.Single(m => m.Name == "MyEvent").ObsoleteMessage);
Assert.IsTrue(typeInfo.Members.Single(m => m.Name == "MyField").Obsolete);
Assert.AreEqual("This field is obsolete!", typeInfo.Members.Single(m => m.Name == "MyField").ObsoleteMessage);
}
private bool MapDestinationCtorToSource(TypeMap typeMap, ConstructorInfo destCtor, TypeInfo sourceTypeInfo,
IMappingOptions options)
{
var parameters = new List<ConstructorParameterMap>();
var ctorParameters = destCtor.GetParameters();
if (ctorParameters.Length == 0 || !options.ConstructorMappingEnabled)
return false;
foreach (var parameter in ctorParameters)
{
var members = new LinkedList<MemberInfo>();
if (!MapDestinationPropertyToSource(members, sourceTypeInfo, parameter.Name, options))
return false;
var resolvers = members.Select(mi => mi.ToMemberGetter());
var param = new ConstructorParameterMap(parameter, resolvers.ToArray());
parameters.Add(param);
}
typeMap.AddConstructorMap(destCtor, parameters);
return true;
}
public void ShouldSetTypePropertyWhenPassingTypeInfoToConstructor()
{
var typeInfo = new TypeInfo(typeof(CustomClass));
var dynamicObject = new DynamicObject(typeInfo);
dynamicObject.Type.ShouldBe(typeInfo);
}
public static TypeInfo GetTypeInfo(this Type type)
{
var typeInfo = new TypeInfo { Type = type, TypeCategory = TypeCategory.Other };
if(type.IsClientInterface())
{
typeInfo.TypeCategory = TypeCategory.ClientInterface;
}
else if(type.IsTask())
{
if(!type.IsGenericType)
{
typeInfo.TypeCategory = TypeCategory.Task;
}
else
{
var taskResultType = type.GetGenericArgument();
if(taskResultType.IsList())
{
typeInfo.TypeCategory = TypeCategory.ReadOnlyList;
typeInfo.Type = taskResultType.GetGenericArgument();
}
else
{
typeInfo.TypeCategory = TypeCategory.GenericTask;
typeInfo.Type = taskResultType;
}
}
}
return typeInfo;
}
public override void CheckSemantic(Scope scope, List<Error> errors)
{
string id_var = "";
//chekeo la semantica del lvalue
LeftExpr.CheckSemantic(scope, errors);
TypeInfo t = LeftExpr.ReturnType;
//en el caso de q sea una variable guardo
//su valor para despues compararlo con el id del ciclo
if (LeftExpr is VariableNode)
id_var = ((VariableNode)LeftExpr).Value;
//chekeo la semantica del rvalue
RigthExpr.CheckSemantic(scope, errors);
TypeInfo t1 = RigthExpr.ReturnType;
if (t != null && t1 != null && t.Name != t1.Name)
{
if (t1.Name == "nil")
{
if (t.Name == "int")
errors.Add(new Error(Row, Col, string.Format("Cannot assign nil to an int")));
}
else if(t1.Name == "void")
errors.Add(new Error(Row, Col, string.Format("The expression that try assign to \"{0}\" not return value", t.Name)));
else
errors.Add(new Error(Row, Col, string.Format("Cannot asssign \"{0}\" to \"{1}\"", t1.Name, t.Name)));
}
else
{
if (countLoop >0 && id_var == scope.IdLoop)
errors.Add(new Error(Row, Col, string.Format("Cannot assign any value to variable \"{0}\" of <for>", scope.IdLoop)));
}
ReturnType = new TypeInfo("void", null, TypeDecl.Base);
}
public static TypeInfo Create(Type rootType, Func<Type, IEntityMetaDataProvider> provider)
{
if (null == rootType)
throw new ArgumentNullException(nameof(rootType));
if (null == provider)
throw new ArgumentNullException(nameof(provider));
TypeInfo typeInfo = new TypeInfo();
typeInfo.Id = rootType.FullName; //NosQL Id.
typeInfo.Pageable = rootType.GetCustomAttribute<GridPageableAttribute>();
typeInfo.Sortable = rootType.GetCustomAttribute<GridSortableAttribute>();
typeInfo.Filterable = rootType.GetCustomAttribute<GridFilterableAttribute>();
typeInfo.Editable = rootType.GetCustomAttribute<GridEditableAttribute>();
GridAttribute ga = rootType.GetCustomAttribute<GridAttribute>();
if (null != ga)
{
typeInfo.Groupable = ga.Groupable;
typeInfo.Height = ga.Height;
}
LoadFields(typeInfo, null, rootType, provider);
return typeInfo;
}
ExpressionInfo(TypeInfo type, Object value) {
this.Type = type;
this.Value = value;
this.IsConstant = true;
this.BoxingKind = BoxingKind.None;
this.Negate = true;
}
public override void CheckSemantic(Scope scope, List<Error> errors)
{
countLoop++;
//chekeo la semantica de la expr inicial
ExprFor.CheckSemantic(scope, errors);
//si el tipo de retorno no es int lanzo un error
if (ExprFor.ReturnType!= null && ExprFor.ReturnType.BaseType.Name != "int")
errors.Add(new Error(Row, Col, "The first expression of <for> must be an int"));
//chekeo la semantica de la expr final
ExprTo.CheckSemantic(scope, errors);
//si no tiene errores esa expr
//si el tipo de retorno no es int lanzo un error
if (ExprTo.ReturnType != null && ExprTo.ReturnType.BaseType.Name != "int")
errors.Add(new Error(Row, Col, "The To'expression of <for> must be an int"));
//creo un nuevo scope
Scope for_scope = new Scope(scope);
//agrego la var de ciclo
for_scope.Variables.Add(IdLoop, new VarInfo(IdLoop, scope.ExistType("int")));
for_scope.IdLoop = IdLoop;
ExprDo.CheckSemantic(for_scope, errors);
ReturnType = new TypeInfo("void", null, TypeDecl.Base);
countLoop--;
}
public ConventionInfo()
{
Source = new TypeInfo();
Target = new TypeInfo();
SourceProp = new PropInfo();
TargetProp = new PropInfo();
}
public When_resolving_two_types_with_same_name()
{
var a = new A { Int32Value = 0, StringValue = "" };
var b = new { Int32Value = 0, StringValue = "" };
var typeInfoA = new TypeInfo(a.GetType());
var typeInfoB = new TypeInfo(b.GetType());
typeInfoA.Name = "TestTypeName";
typeInfoB.Name = "TestTypeName";
typeInfoA.Namespace = "TestNamespace";
typeInfoB.Namespace = "TestNamespace";
typeInfoA.DeclaringType = null;
typeInfoB.DeclaringType = null;
var typeResolver = new TypeResolver();
resolvedTypeA1 = typeResolver.ResolveType(typeInfoA);
resolvedTypeB1 = typeResolver.ResolveType(typeInfoB);
resolvedTypeA2 = typeResolver.ResolveType(typeInfoA);
resolvedTypeB2 = typeResolver.ResolveType(typeInfoB);
}
private void EnumDCInterfaceMembers(TypeInfo info, EnumMembersHandler handler) {
var generatedEntityInfo = info.FindDCXPClassInfo();
var dcPropertyInfos = DCPropertyInfos(generatedEntityInfo);
foreach (DCPropertyInfo dcPropertyInfo in dcPropertyInfos){
handler(dcPropertyInfo, dcPropertyInfo.Name);
}
}
static bool isCallingResourceManagerCtor(IList<Instruction> instrs, int ldstrIndex, TypeInfo typeInfo)
{
try {
int index = ldstrIndex + 1;
var ldtoken = instrs[index++];
if (ldtoken.OpCode.Code != Code.Ldtoken)
return false;
if (!new SigComparer().Equals(typeInfo.type.TypeDef, ldtoken.Operand as ITypeDefOrRef))
return false;
if (!checkCalledMethod(instrs[index++], "System.Type", "(System.RuntimeTypeHandle)"))
return false;
if (!checkCalledMethod(instrs[index++], "System.Reflection.Assembly", "()"))
return false;
var newobj = instrs[index++];
if (newobj.OpCode.Code != Code.Newobj)
return false;
if (newobj.Operand.ToString() != "System.Void System.Resources.ResourceManager::.ctor(System.String,System.Reflection.Assembly)")
return false;
return true;
}
catch (ArgumentOutOfRangeException) {
return false;
}
catch (IndexOutOfRangeException) {
return false;
}
}
/// <summary>
/// Prompts the user to edit a value.
/// </summary>
public Variant ShowDialog(Session session, NodeId nodeId)
{
m_session = session;
m_nodeId = nodeId;
#region Task #B2 - Write Value
// generate a default value based on the data type.
m_value = Variant.Null;
m_sourceType = GetExpectedType(session, nodeId);
if (m_sourceType != null)
{
m_value = new Variant(TypeInfo.GetDefaultValue(m_sourceType.BuiltInType), m_sourceType);
}
// cast the value to a string.
ValueTB.Text = (string)TypeInfo.Cast(m_value.Value, m_value.TypeInfo, BuiltInType.String);
#endregion
if (ShowDialog() != DialogResult.OK)
{
return Variant.Null;
}
return m_value;
}
public TypeMap(TypeInfo sourceType, TypeInfo destinationType, MemberList memberList)
{
_sourceType = sourceType;
_destinationType = destinationType;
Profile = ConfigurationStore.DefaultProfileName;
ConfiguredMemberList = memberList;
}
LocalInfo(TypeInfo type, String name, int index, Label beginLabel, Label endLabel) {
this.type = type;
this.name = name;
this.index = index;
this.beginLabel = beginLabel;
this.endLabel = endLabel;
}
public DataContract2ClassBuilder(string ns, Command cmd, DataTable dt)
: base(ns, cmd)
{
this.dt = dt;
foreach (DataColumn column in dt.Columns)
{
TypeInfo ty = new TypeInfo { type = column.DataType };
foreach (DataRow row in dt.Rows)
{
if (row[column] == DBNull.Value)
ty.Nullable = true;
break;
}
dict.Add(column, ty);
}
builder.AddUsing("System");
builder.AddUsing("System.Collections.Generic");
builder.AddUsing("System.Data");
builder.AddUsing("System.Linq");
builder.AddUsing("Sys.Data");
AddOptionalUsing();
}
public void It_can_create_a_deep_clone_of_itself()
{
var type1 = new TypeInfo
{
Name = "MyType",
Kind = TypeKind.Class,
Obsolete = true,
ObsoleteMessage = "I'm obsolete!",
Members =
{
new MemberInfo
{
Changes = { new MemberChangeInfo() }
}
},
Changes =
{
new TypeChangeInfo()
}
};
var type2 = type1.Clone();
Assert.AreNotSame(type1, type2);
Assert.AreEqual(type1.Name, type2.Name);
Assert.AreEqual(type1.Kind, type2.Kind);
Assert.AreEqual(type1.Obsolete, type2.Obsolete);
Assert.AreEqual(type1.ObsoleteMessage, type2.ObsoleteMessage);
Assert.AreNotSame(type1.Members, type2.Members);
Assert.AreNotSame(type1.Members.Single(), type2.Members.Single());
Assert.AreNotSame(type1.Members.Single().Changes.Single(), type2.Members.Single().Changes.Single());
Assert.AreNotSame(type1.Changes, type2.Changes);
Assert.AreNotSame(type1.Changes.Single(), type2.Changes.Single());
}
public static void TypeInfo_CustomAttributes(TypeInfo typeInfo)
{
String typeName = typeInfo.NameString();
if (typeName == null)
return;
ReflectionEventSource.Log.TypeInfo_CustomAttributes(typeName);
}
string HaveField(TypeInfo t)
{
for (int i = 0; i < t.Record_parameters.Count(); i++)
{
if (Field == t.Record_parameters[i].Id) return t.Record_parameters[i].Type;
}
return "";
}
private static void CheckForTypeConversion(ExpressionSyntax expression, TypeInfo typeInfo, Action<Diagnostic> reportDiagnostic, string filePath)
{
if (typeInfo.Type != null && typeInfo.Type.IsValueType && typeInfo.ConvertedType != null && !typeInfo.ConvertedType.IsValueType)
{
reportDiagnostic(Diagnostic.Create(ValueTypeToReferenceTypeInAStringConcatenationRule, expression.GetLocation(), new object[] { typeInfo.Type.ToDisplayString() }));
HeapAllocationAnalyzerEventSource.Logger.BoxingAllocationInStringConcatenation(filePath);
}
}
private static IEnumerable<TargetElementAttribute> GetValidTargetElementAttributes(
TypeInfo typeInfo,
ErrorSink errorSink)
{
var targetElementAttributes = typeInfo.GetCustomAttributes<TargetElementAttribute>(inherit: false);
return targetElementAttributes.Where(attribute => ValidTargetElementAttributeNames(attribute, errorSink));
}
void buildTypeDocumentation(TypeInfo type, TypeMemberNode typeDeclaration) {
var comment = ParserHelper.decodeDocumentation(context.Text, typeDeclaration.DocumentationOffset,
typeDeclaration.DocumentationLength);
memberKind = MemberKind.Type;
this.type = type;
node = typeDeclaration;
appendDocumentation(getIdString(type), comment);
}
private readonly TypeInfo m_typeInfo; // Corresponding type info
#endregion Fields
#region Constructors
public ConvEnumExternal(ConverterInfo info, TypeInfo typeInfo, Type managedType)
{
m_typeInfo = typeInfo;
m_managedType = managedType;
info.AddToSymbolTable(typeInfo, ConvType.Enum, this);
info.RegisterType(managedType, this);
}
public MiniParameterInfo(CorElementType elementType, TypeInfo parameterType)
{
System.Diagnostics.Contracts.Contract.Requires(parameterType != null);
System.Diagnostics.Contracts.Contract.Requires(IsValid(elementType));
_elementType = elementType;
_paramType = parameterType;
}
static void setArrayInitializerTypes(ArrayInitializerExpressionNode initializer, TypeInfo type) {
initializer.getUserData(typeof(ExpressionInfo)).Type = type;
foreach (var e in initializer.Values) {
if (e.ExpressionKind == ExpressionKind.ArrayInitializer) {
setArrayInitializerTypes((ArrayInitializerExpressionNode)e, type.ElementType);
}
}
}
void ICloneTargetSetup.HandleObject <T>(T source, T target, CloneBehavior behavior, TypeInfo behaviorTarget)
{
// Since "fallback to default" is triggered by source being equal to the currently handled object,
// we need to make sure that this cannot be triggered accidentally by auto-generated clone lambdas.
// Only allow the fallback when the object in question is actually cloned by user code!
bool calledFromUserCode = this.currentObject is ICloneExplicit || this.currentCloneType.Surrogate != null;
if (object.ReferenceEquals(source, this.currentObject) && calledFromUserCode)
{
this.PrepareObjectChildCloneGraph(this.currentObject, target, this.currentCloneType);
}
else if (behaviorTarget != null)
{
this.PushCloneBehavior(new LocalCloneBehavior(behaviorTarget, behavior));
this.PrepareObjectCloneGraph(source, target, null);
this.PopCloneBehavior();
}
else if (behavior == CloneBehavior.Reference)
{
return;
}
else if (behavior == CloneBehavior.WeakReference)
{
if (!object.ReferenceEquals(source, null))
{
this.dropWeakReferences.Add(source);
}
}
else
{
this.PrepareObjectCloneGraph(source, target, null, behavior);
}
}
public override TypeInfo MapType(TypeInfo type)
{
return(builder.MapType(type));
}
private static bool IsApplicableAttribute(TypeInfo type, TypeInfo targetType, string targetTypeName)
{
return(type != null && AreEquivalent(targetType, type) ||
targetTypeName != null && type.FullName == targetTypeName);
}
public TypeCustomAttributeProvider(TypeInfo provider)
{
_provider = provider;
}
private IGraphType GetGraphType(GraphTypeAdapter typeAdapter, TypeResolver typeResolver, TypeInfo typeInfo)
{
var graphTypeInfo = typeResolver.DeriveType(typeInfo);
return(typeAdapter.DeriveType(graphTypeInfo));
}
public static MethodInfo GetPrivateStaticMethod(this TypeInfo t, string name)
{
return(t.GetMethod(name, BindingFlags.NonPublic | BindingFlags.Static));
}
public static MethodInfo[] GetPublicInstanceOverloadedMethods(this TypeInfo t, string name)
{
return(t.GetMethods(BindingFlags.Public | BindingFlags.Instance).Where(m => m.Name == name).ToArray());
}
public static MethodInfo GetPublicInstanceMethod(this TypeInfo t, string name)
{
return(t.GetMethod(name, BindingFlags.Public | BindingFlags.Instance));
}
/// <summary>
/// Checks if the conversion might change the resultant boxed type.
/// Similar boxing checks are performed elsewhere, but in this case we need to perform the check on the entire conditional expression.
/// This will make sure the resultant cast is proper for the type of the conditional expression.
/// </summary>
private bool ReplacementBreaksBoxingInConditionalExpression(TypeInfo originalExpressionTypeInfo, TypeInfo newExpressionTypeInfo, ExpressionSyntax previousOriginalNode, ExpressionSyntax previousReplacedNode)
{
// If the resultant types are different and it is boxing to the converted type then semantics could be changing.
if (!Equals(originalExpressionTypeInfo.Type, newExpressionTypeInfo.Type))
{
var originalConvertedTypeConversion = this.OriginalSemanticModel.ClassifyConversion(previousOriginalNode, originalExpressionTypeInfo.ConvertedType);
var newExpressionConvertedTypeConversion = this.SpeculativeSemanticModel.ClassifyConversion(previousReplacedNode, newExpressionTypeInfo.ConvertedType);
if (originalConvertedTypeConversion.IsBoxing && newExpressionConvertedTypeConversion.IsBoxing)
{
return(true);
}
}
return(false);
}
public static object ChangeType(this object source, TypeInfo newType) => Convert.ChangeType(source, newType.AsType());
private static void CheckDependencies(IList <Sharpen.Tuple <RuleDependencyAttribute, ICustomAttributeProvider> > dependencies, TypeInfo recognizerType)
{
string[] ruleNames = GetRuleNames(recognizerType);
int[] ruleVersions = GetRuleVersions(recognizerType, ruleNames);
RuleDependencyChecker.RuleRelations relations = ExtractRuleRelations(recognizerType);
StringBuilder errors = new StringBuilder();
foreach (Sharpen.Tuple <RuleDependencyAttribute, ICustomAttributeProvider> dependency in dependencies)
{
if (!dependency.Item1.Recognizer.GetTypeInfo().IsAssignableFrom(recognizerType))
{
continue;
}
// this is the rule in the dependency set with the highest version number
int effectiveRule = dependency.Item1.Rule;
if (effectiveRule < 0 || effectiveRule >= ruleVersions.Length)
{
string message = string.Format("Rule dependency on unknown rule {0}@{1} in {2}", dependency.Item1.Rule, dependency.Item1.Version, dependency.Item1.Recognizer.ToString());
errors.AppendLine(dependency.Item2.ToString());
errors.AppendLine(message);
continue;
}
Dependents dependents = Dependents.Self | dependency.Item1.Dependents;
ReportUnimplementedDependents(errors, dependency, dependents);
BitSet @checked = new BitSet();
int highestRequiredDependency = CheckDependencyVersion(errors, dependency, ruleNames, ruleVersions, effectiveRule, null);
if ((dependents & Dependents.Parents) != 0)
{
BitSet parents = relations.parents[dependency.Item1.Rule];
for (int parent = parents.NextSetBit(0); parent >= 0; parent = parents.NextSetBit(parent + 1))
{
if (parent < 0 || parent >= ruleVersions.Length || @checked.Get(parent))
{
continue;
}
@checked.Set(parent);
int required = CheckDependencyVersion(errors, dependency, ruleNames, ruleVersions, parent, "parent");
highestRequiredDependency = Math.Max(highestRequiredDependency, required);
}
}
if ((dependents & Dependents.Children) != 0)
{
BitSet children = relations.children[dependency.Item1.Rule];
for (int child = children.NextSetBit(0); child >= 0; child = children.NextSetBit(child + 1))
{
if (child < 0 || child >= ruleVersions.Length || @checked.Get(child))
{
continue;
}
@checked.Set(child);
int required = CheckDependencyVersion(errors, dependency, ruleNames, ruleVersions, child, "child");
highestRequiredDependency = Math.Max(highestRequiredDependency, required);
}
}
if ((dependents & Dependents.Ancestors) != 0)
{
BitSet ancestors = relations.GetAncestors(dependency.Item1.Rule);
for (int ancestor = ancestors.NextSetBit(0); ancestor >= 0; ancestor = ancestors.NextSetBit(ancestor + 1))
{
if (ancestor < 0 || ancestor >= ruleVersions.Length || @checked.Get(ancestor))
{
continue;
}
@checked.Set(ancestor);
int required = CheckDependencyVersion(errors, dependency, ruleNames, ruleVersions, ancestor, "ancestor");
highestRequiredDependency = Math.Max(highestRequiredDependency, required);
}
}
if ((dependents & Dependents.Descendants) != 0)
{
BitSet descendants = relations.GetDescendants(dependency.Item1.Rule);
for (int descendant = descendants.NextSetBit(0); descendant >= 0; descendant = descendants.NextSetBit(descendant + 1))
{
if (descendant < 0 || descendant >= ruleVersions.Length || @checked.Get(descendant))
{
continue;
}
@checked.Set(descendant);
int required = CheckDependencyVersion(errors, dependency, ruleNames, ruleVersions, descendant, "descendant");
highestRequiredDependency = Math.Max(highestRequiredDependency, required);
}
}
int declaredVersion = dependency.Item1.Version;
if (declaredVersion > highestRequiredDependency)
{
string message = string.Format("Rule dependency version mismatch: {0} has maximum dependency version {1} (expected {2}) in {3}", ruleNames[dependency.Item1.Rule], highestRequiredDependency, declaredVersion, dependency.Item1.Recognizer.ToString());
errors.AppendLine(dependency.Item2.ToString());
errors.AppendLine(message);
}
}
if (errors.Length > 0)
{
throw new InvalidOperationException(errors.ToString());
}
}
public static IList <Sharpen.Tuple <RuleDependencyAttribute, ICustomAttributeProvider> > GetDependencies(TypeInfo clazz)
{
IList <Sharpen.Tuple <RuleDependencyAttribute, ICustomAttributeProvider> > result = new List <Sharpen.Tuple <RuleDependencyAttribute, ICustomAttributeProvider> >();
GetElementDependencies(AsCustomAttributeProvider(clazz), result);
foreach (ConstructorInfo ctor in clazz.DeclaredConstructors)
{
GetElementDependencies(AsCustomAttributeProvider(ctor), result);
foreach (ParameterInfo parameter in ctor.GetParameters())
{
GetElementDependencies(AsCustomAttributeProvider(parameter), result);
}
}
foreach (FieldInfo field in clazz.DeclaredFields)
{
GetElementDependencies(AsCustomAttributeProvider(field), result);
}
foreach (MethodInfo method in clazz.DeclaredMethods)
{
GetElementDependencies(AsCustomAttributeProvider(method), result);
#if COMPACT
if (method.ReturnTypeCustomAttributes != null)
{
GetElementDependencies(AsCustomAttributeProvider(method.ReturnTypeCustomAttributes), result);
}
#else
if (method.ReturnParameter != null)
{
GetElementDependencies(AsCustomAttributeProvider(method.ReturnParameter), result);
}
#endif
foreach (ParameterInfo parameter in method.GetParameters())
{
GetElementDependencies(AsCustomAttributeProvider(parameter), result);
}
}
return(result);
}
public static T GetPublicInstanceField <T>(this TypeInfo t, object instance, string field)
{
return((T)t.GetField(field, BindingFlags.Instance | BindingFlags.Public)?.GetValue(instance));
}
protected static ICustomAttributeProvider AsCustomAttributeProvider(TypeInfo type)
{
return(new TypeCustomAttributeProvider(type));
}
public SmartType(Type type, ConstructorRetrieval constructorRetrieval)
{
_type = type;
_constructorRetrieval = constructorRetrieval;
_typeInfo = _type.GetTypeInfo();
}
void OnSearchBarButtonPressed(object sender, EventArgs args)
{
// Get the search text.
SearchBar searchBar = (SearchBar)sender;
string searchText = searchBar.Text;
// Create a List and initialize the results Label.
var list = new List <Tuple <Type, Type> >();
_resultsLabel.Text = string.Empty;
// Get Xamarin.Forms assembly.
Assembly xamarinFormsAssembly = typeof(View).GetTypeInfo().Assembly;
// Loop through all the types.
foreach (Type type in xamarinFormsAssembly.ExportedTypes)
{
TypeInfo typeInfo = type.GetTypeInfo();
// Public types only.
if (typeInfo.IsPublic)
{
// Loop through the properties.
foreach (PropertyInfo property in typeInfo.DeclaredProperties)
{
// Check for a match
if (property.Name.Equals(searchText))
{
// Add it to the list.
list.Add(Tuple.Create <Type, Type>(type, property.PropertyType));
}
}
}
}
if (list.Count == 0)
{
_resultsLabel.Text =
String.Format("No Xamarin.Forms properties with " +
"the name of {0} were found",
searchText);
}
else
{
_resultsLabel.Text = "The ";
foreach (Tuple <Type, Type> tuple in list)
{
_resultsLabel.Text +=
String.Format("{0} type defines a property named {1} of type {2}",
tuple.Item1.Name, searchText, tuple.Item2.Name);
if (tuple != list.Last())
{
_resultsLabel.Text += "; and the ";
}
}
_resultsLabel.Text += ".";
}
}
private static bool AreEquivalent(TypeInfo type, TypeInfo other)
{
// TODO: Unify NoPIA interfaces
// https://github.com/dotnet/corefx/issues/2101
return(type.Equals(other));
}
private Dictionary <string, CommandRecord> LoadCommands()
{
Dictionary <string, CommandRecord> commands = new Dictionary <string, CommandRecord>();
string dir = new FileInfo(Assembly.GetEntryAssembly().Location).Directory.FullName;
DirectoryInfo directoryInfo = new DirectoryInfo(dir);
FileInfo[] files = directoryInfo.GetFiles("*.dll");
Type commandsetType = typeof(CommandSet);
string typeName;
string methodName;
string command;
IEnumerable <CommandAttribute> commandAttributes;
foreach (FileInfo file in files)
{
Assembly assembly = Assembly.Load(AssemblyLoadContext.GetAssemblyName(file.FullName));
Type[] types = assembly.GetTypes();
foreach (Type type in types)
{
TypeInfo typeInfo = type.GetTypeInfo();
if (typeInfo.IsArray == true)
{
continue;
}
if (typeInfo.IsEnum == true)
{
continue;
}
if (typeInfo.IsAbstract == true)
{
continue;
}
if (typeInfo.IsInterface == true)
{
continue;
}
if (typeInfo.IsClass == false)
{
continue;
}
if (!commandsetType.IsAssignableFrom(type))
{
continue;
}
typeName = type.Name;
if (typeName.EndsWith("Commands"))
{
typeName = typeName.Substring(0, typeName.Length - 8);
}
typeName = typeName.ToLower();
foreach (MethodInfo method in type.GetMethods(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly))
{
methodName = method.Name.ToLower();
commandAttributes = method.GetCustomAttributes <CommandAttribute>();
foreach (CommandAttribute commandAttribute in commandAttributes)
{
command = commandAttribute.Name.Trim().ToLower();
if (command.Length <= 0)
{
continue;
}
commands[command] = new CommandRecord(command, type, method);
}
}
}
}
return(commands);
}
private static DebuggerTypeProxyAttribute GetApplicableDebuggerTypeProxyAttribute(TypeInfo type)
{
// includes inherited attributes. The debugger uses the first attribute if multiple are applied.
var result = type.GetCustomAttributes <DebuggerTypeProxyAttribute>().FirstOrDefault();
if (result != null)
{
return(result);
}
// TODO (tomat): which assembly should we look at for proxy attributes?
foreach (DebuggerTypeProxyAttribute attr in type.Assembly.GetCustomAttributes <DebuggerTypeProxyAttribute>())
{
if (IsApplicableAttribute(type, attr.Target.GetTypeInfo(), attr.TargetTypeName))
{
return(attr);
}
}
return(null);
}
public ParameterExpression(TypeInfo parameterType, string parameterName, int instanceId)
{
ParameterType = parameterType;
ParameterName = parameterName;
InstanceId = instanceId;
}
internal static PersistRequestBuilderTask RemoveWithVersionCheck(TypeInfo type, BitArray availableFields)
{
return(new PersistRequestBuilderTask(PersistRequestKind.Remove, type, availableFields, null, true));
}
internal static PersistRequestBuilderTask Remove(TypeInfo type)
{
return(new PersistRequestBuilderTask(PersistRequestKind.Remove, type, null, null, false));
}
internal static MemberInfo ResolveMember(object obj, string memberName, bool callableOnly)
{
TypeInfo type = obj.GetType().GetTypeInfo();
// case-sensitive:
TypeInfo currentType = type;
while (true)
{
if (!callableOnly)
{
var field = currentType.GetDeclaredField(memberName);
if (field != null)
{
return(field);
}
var property = currentType.GetDeclaredProperty(memberName);
if (property != null)
{
var getter = property.GetMethod;
if (getter != null)
{
return(getter);
}
}
}
var method = currentType.GetDeclaredMethod(memberName, Type.EmptyTypes);
if (method != null)
{
return(method);
}
if (currentType.BaseType == null)
{
break;
}
currentType = currentType.BaseType.GetTypeInfo();
}
// case-insensitive:
currentType = type;
while (true)
{
IEnumerable <MemberInfo> members;
if (callableOnly)
{
members = type.DeclaredMethods;
}
else
{
members = ((IEnumerable <MemberInfo>)type.DeclaredFields).Concat(type.DeclaredProperties);
}
MemberInfo candidate = null;
foreach (var member in members)
{
if (StringComparer.OrdinalIgnoreCase.Equals(memberName, member.Name))
{
if (candidate != null)
{
return(null);
}
MethodInfo method;
if (member is FieldInfo)
{
candidate = member;
}
else if ((method = member as MethodInfo) != null)
{
if (method.GetParameters().Length == 0)
{
candidate = member;
}
}
else
{
var getter = ((PropertyInfo)member).GetMethod;
if (getter?.GetParameters().Length == 0)
{
candidate = member;
}
}
}
}
if (candidate != null)
{
return(candidate);
}
if (currentType.BaseType == null)
{
break;
}
currentType = currentType.BaseType.GetTypeInfo();
}
return(null);
}
internal static PersistRequestBuilderTask UpdateWithVersionCheck(TypeInfo type, BitArray availableFields, BitArray changedField)
{
return(new PersistRequestBuilderTask(PersistRequestKind.Update, type, availableFields, changedField, true));
}
public IEnumerable <PropertyInfo> Get(TypeInfo parameter) => parameter.GetProperties();
internal static PersistRequestBuilderTask Update(TypeInfo type, BitArray changedFields)
{
return(new PersistRequestBuilderTask(PersistRequestKind.Update, type, null, changedFields, false));
}
void ICloneTargetSetup.HandleValue <T>(ref T source, ref T target, CloneBehavior behavior, TypeInfo behaviorTarget)
{
if (typeof(T) == this.currentCloneType.Type.AsType())
{
// Structs can't contain themselfs. If source's type is equal to our current clone type, this is a handle-self call.
this.PrepareValueChildCloneGraph <T>(ref source, ref target, this.currentCloneType);
}
else if (behaviorTarget != null)
{
this.PushCloneBehavior(new LocalCloneBehavior(behaviorTarget, behavior));
this.PrepareValueCloneGraph <T>(ref source, ref target, null);
this.PopCloneBehavior();
}
else
{
this.PrepareValueCloneGraph <T>(ref source, ref target, null);
}
}
// Constructors
internal static PersistRequestBuilderTask Insert(TypeInfo type)
{
return(new PersistRequestBuilderTask(PersistRequestKind.Insert, type, null, null, false));
}
private Type GetEquivalentType(Type type)
{
Type equiv;
if (_equivalentTypeCache == null)
{
// Pre-loading with the non-generic IQueryable and IEnumerable not only covers this case
// without any reflection-based introspection, but also means the slightly different
// code needed to catch this case can be omitted safely.
_equivalentTypeCache = new Dictionary <Type, Type>
{
{ typeof(IQueryable), typeof(IEnumerable) },
{ typeof(IEnumerable), typeof(IEnumerable) }
};
}
if (!_equivalentTypeCache.TryGetValue(type, out equiv))
{
Type pubType = GetPublicType(type);
TypeInfo info = pubType.GetTypeInfo();
if (info.IsInterface && info.IsGenericType)
{
Type genericType = info.GetGenericTypeDefinition();
if (genericType == typeof(IOrderedEnumerable <>))
{
equiv = pubType;
}
else if (genericType == typeof(IOrderedQueryable <>))
{
equiv = typeof(IOrderedEnumerable <>).MakeGenericType(info.GenericTypeArguments[0]);
}
else if (genericType == typeof(IEnumerable <>))
{
equiv = pubType;
}
else if (genericType == typeof(IQueryable <>))
{
equiv = typeof(IEnumerable <>).MakeGenericType(info.GenericTypeArguments[0]);
}
}
if (equiv == null)
{
var interfacesWithInfo = info.ImplementedInterfaces.Select(IntrospectionExtensions.GetTypeInfo).ToArray();
var singleTypeGenInterfacesWithGetType = interfacesWithInfo
.Where(i => i.IsGenericType && i.GenericTypeArguments.Length == 1)
.Select(i => new { Info = i, GenType = i.GetGenericTypeDefinition() })
.ToArray();
Type typeArg = singleTypeGenInterfacesWithGetType
.Where(i => i.GenType == typeof(IOrderedQueryable <>) || i.GenType == typeof(IOrderedEnumerable <>))
.Select(i => i.Info.GenericTypeArguments[0])
.Distinct()
.SingleOrDefault();
if (typeArg != null)
{
equiv = typeof(IOrderedEnumerable <>).MakeGenericType(typeArg);
}
else
{
typeArg = singleTypeGenInterfacesWithGetType
.Where(i => i.GenType == typeof(IQueryable <>) || i.GenType == typeof(IEnumerable <>))
.Select(i => i.Info.GenericTypeArguments[0])
.Distinct()
.Single();
equiv = typeof(IEnumerable <>).MakeGenericType(typeArg);
}
}
_equivalentTypeCache.Add(type, equiv);
}
return(equiv);
}
private static string[] GetRuleNames(TypeInfo recognizerClass)
{
FieldInfo ruleNames = recognizerClass.DeclaredFields.First(i => i.Name == "ruleNames");
return((string[])ruleNames.GetValue(null));
}
