/// <summary> /// Checks parameters for problems /// </summary> /// <param name="parameter"></param> /// <returns></returns> public override ProblemCollection Check(Parameter parameter) { #if DEBUG lock (_debugLock) { #endif UniqueProblemCollection problems = new UniqueProblemCollection(); string currentTypeNamespace = parameter.DeclaringMethod.DeclaringType.FullName; string baseNamespace = GetNamespaceFromTypeName(currentTypeNamespace, BaseNamespaceMoniker); if (parameter.DeclaringMethod.Body.SourceContext.IsValid) { if (!string.IsNullOrEmpty(baseNamespace)) { CallTestObjectValue(problems, null, baseNamespace, parameter.Type, string.Format("Parameter {0} declared in a method in namespace {{0}} may not reference namespace {{1}}", parameter.Name)); } } return(problems.Problems); #if DEBUG } #endif }
/// <summary> /// Checks types for problems /// </summary> /// <param name="type"></param> /// <returns></returns> public override ProblemCollection Check(TypeNode type) { #if DEBUG lock (_debugLock) { #endif UniqueProblemCollection problems = new UniqueProblemCollection(); string currentTypeNamespace = type.FullName; string baseNamespace = GetNamespaceFromTypeName(currentTypeNamespace, BaseNamespaceMoniker); if (!string.IsNullOrEmpty(baseNamespace)) { string typeName; //Determine the name of the type switch (type.NodeType) { case NodeType.DelegateNode: typeName = "Delegate"; break; case NodeType.Interface: typeName = "Interface"; break; default: typeName = "Class"; break; } if (type.BaseType != null) { CallTestObjectValue(problems, null, baseNamespace, type.BaseType, typeName + " in namespace {0} may not be based on a class from namespace {1}"); } //Check implemented interfaces foreach (InterfaceNode interfaceType in type.Interfaces) { CallTestObjectValue(problems, null, baseNamespace, interfaceType.FullName, typeName + " in namespace {0} may not implement an interface from namespace {1}"); } if (type is DelegateNode) { DelegateNode delegateNode = type as DelegateNode; CallTestObjectValue(problems, null, baseNamespace, delegateNode.ReturnType, "Delegate in namespace {0} may not have a return type from namespace {1}"); foreach (Parameter parameter in delegateNode.Parameters) { TestObjectValue(problems, null, baseNamespace, parameter.Type, "Delegate parameter in namespace {0} may not reference namespace {1}"); } } } return(problems.Problems); #if DEBUG } #endif }
internal override void TestObjectValue(UniqueProblemCollection problems, SourceContext?sourceContext, string baseNamespace, object value, string messageFormat) { if (sourceContext.HasValue && !sourceContext.Value.IsValid) { return; } //Determine the type of value TestObjectNamespaces(value, (instructionTypeName) => { string instructionBaseNamespace = GetNamespaceFromTypeName(instructionTypeName, ParentNamespaceMoniker); if (instructionBaseNamespace != null) { Resolution res = new Resolution("Using invalid namespace", messageFormat, baseNamespace, instructionBaseNamespace); if (sourceContext.HasValue) { problems.Add(new Problem(res, sourceContext.Value)); } else { problems.Add(new Problem(res)); } } }); }
/// <summary> /// Parses member functions looking for bad namespaces /// </summary> /// <param name="member"></param> /// <returns></returns> public override ProblemCollection Check(Member member) { #if DEBUG lock (_debugLock) { #endif UniqueProblemCollection problems = new UniqueProblemCollection(); //Check to see if instructions in a Method are illeagal if (member is Method) { Method method = member as Method; Check(problems, method); } else if (member is Field) { Field field = member as Field; Check(problems, field); } else if (member is PropertyNode) { PropertyNode property = member as PropertyNode; Check(problems, property); } else if (member is EventNode) { EventNode eventNode = member as EventNode; string currentTypeNamespace = eventNode.DeclaringType.FullName; string baseNamespace = GetNamespaceFromTypeName(currentTypeNamespace, BaseNamespaceMoniker); if (!string.IsNullOrEmpty(baseNamespace)) { CallTestObjectValue(problems, null, baseNamespace, eventNode.HandlerType, string.Format("Event {0} in namespace {{0}} may not reference namespace {{1}}", eventNode.Name)); } } else { string type = member.DeclaringType.FullName; } return(problems.Problems); #if DEBUG } #endif }
/// <summary> /// Checks properties for errors /// </summary> /// <param name="problems"></param> /// <param name="property"></param> private void Check(UniqueProblemCollection problems, PropertyNode property) { string currentTypeNamespace = property.DeclaringType.FullName; string baseNamespace = GetNamespaceFromTypeName(currentTypeNamespace, BaseNamespaceMoniker); if (!string.IsNullOrEmpty(baseNamespace)) { CallTestObjectValue(problems, null, baseNamespace, property.Type, string.Format("Property {0} in namespace {{0}} may not reference namespace {{1}}", property.Name)); } }
/// <summary> /// Checks fields for errors /// </summary> /// <param name="problems"></param> /// <param name="field"></param> private void Check(UniqueProblemCollection problems, Field field) { string currentTypeNamespace = field.DeclaringType.FullName; string baseNamespace = GetNamespaceFromTypeName(currentTypeNamespace, BaseNamespaceMoniker); if (field.Type.NodeType != NodeType.DelegateNode) { if (!string.IsNullOrEmpty(baseNamespace)) { CallTestObjectValue(problems, null, baseNamespace, field.Type, string.Format("Field {0} in namespace {{0}} may not reference namespace {{1}}", field.Name)); } } }
/// <summary> /// Performs chaks on methods /// </summary> /// <param name="problems"></param> /// <param name="method"></param> private void Check(UniqueProblemCollection problems, Method method) { string currentTypeNamespace = method.DeclaringType.FullName; string baseNamespace = GetNamespaceFromTypeName(currentTypeNamespace, BaseNamespaceMoniker); if (!string.IsNullOrEmpty(baseNamespace)) { //Validate the return type CallTestObjectValue(problems, null, baseNamespace, method.ReturnType, "Return value in namespace {0} may not reference namespace {1}"); foreach (Instruction instruction in GetValidInstructions(method.Instructions)) { //Some values are collections of values. We need to check each if (instruction.Value is ICollection) { foreach (object instructionValue in (instruction.Value as ICollection)) { if (instructionValue != null) { CallTestObjectValue(problems, instruction.SourceContext, baseNamespace, instructionValue, "Method in namespace {0} may not reference namespace {1}"); } } } else { if (instruction.Value != null) { CallTestObjectValue(problems, instruction.SourceContext, baseNamespace, instruction.Value, "Method in namespace {0} may not reference namespace {1}"); } } } } }
private void CallTestObjectValue(UniqueProblemCollection problems, SourceContext?sourceContext, string baseNamespace, object type, string messageFormat) { try { TestObjectValue(problems, sourceContext, baseNamespace, type, messageFormat); } catch (Exception ex) { Resolution res = new Resolution("Exception checking code {0}\n{1}", ex.Message, ex.StackTrace); if (sourceContext.HasValue) { problems.Add(new Problem(res, sourceContext.Value)); } else { problems.Add(new Problem(res)); } } }
internal abstract void TestObjectValue(UniqueProblemCollection problems, SourceContext?sourceContext, string baseNamespace, object value, string messageFormat);