private void ParseMethod()
{
AEvaluator methodName = Pop();
if (methodName.EvalType != EEvaluatorType.Getter)
{
throw new TemplateParserException(ETemplateParserError.Method_IncorrectName, PeekToken());
}
MethodEvaluator method = new MethodEvaluator(methodName.ToString());
int count = m_Evaluators.Count;
while (HasTokens() && PeekToken().Value[0] != TemplateConst.PARENT_CLOSE)
{
ParseAccess();
}
ConsumeToken();
for (int x = count; x < m_Evaluators.Count; x++)
{
method.AddArgument(m_Evaluators[x]);
}
while (m_Evaluators.Count > count)
{
Pop();
}
Push(method);
}
FindMatchesReturnsMatchOnMethodWithoutGenericTypeConstraintsOrParameters()
{
var method = new TestMethodDefinition
{
GenericTypeParameters = Array.Empty <string>(),
Parameters = Array.Empty <IParameterDefinition>()
};
var oldItems = new List <IMethodDefinition>
{
method
};
var newItems = new List <IMethodDefinition>
{
method
};
var sut = new MethodEvaluator();
var actual = sut.FindMatches(oldItems, newItems);
actual.ItemsAdded.Should().BeEmpty();
actual.ItemsRemoved.Should().BeEmpty();
actual.MatchingItems.Should().HaveCount(1);
actual.MatchingItems.First().OldItem.Should().BeEquivalentTo(method);
actual.MatchingItems.First().NewItem.Should().BeEquivalentTo(method);
}
FindMatchesDoesNotReturnsMatchOnRenamedMethodWhenMultipleTargetOptionsAvailable()
{
var oldMethod = new TestMethodDefinition
{
GenericTypeParameters = new List <string>
{
"TKey",
"TValue"
},
Parameters = new List <IParameterDefinition>
{
new TestParameterDefinition
{
Type = "List<string>"
},
new TestParameterDefinition
{
Type = "Guid"
},
new TestParameterDefinition
{
Type = "CancellationToken"
}
}
};
var newMethod = new TestMethodDefinition().Set(x =>
{
x.GenericTypeParameters = oldMethod.GenericTypeParameters;
x.Parameters = oldMethod.Parameters;
});
var otherNewMethod = new TestMethodDefinition().Set(x =>
{
x.GenericTypeParameters = oldMethod.GenericTypeParameters;
x.Parameters = oldMethod.Parameters;
});
var oldItems = new List <IMethodDefinition>
{
oldMethod
};
var newItems = new List <IMethodDefinition>
{
newMethod,
otherNewMethod
};
var sut = new MethodEvaluator();
var actual = sut.FindMatches(oldItems, newItems);
actual.ItemsAdded.Should().HaveCount(2);
actual.ItemsAdded.First().Should().BeEquivalentTo(newMethod);
actual.ItemsAdded.Skip(1).First().Should().BeEquivalentTo(otherNewMethod);
actual.ItemsRemoved.Should().HaveCount(1);
actual.ItemsRemoved.First().Should().BeEquivalentTo(oldMethod);
actual.MatchingItems.Should().BeEmpty();
}
FindMatchesReturnsMatchOnMethodWithGenericTypeCountChanged()
{
var oldMethod = new TestMethodDefinition
{
GenericTypeParameters = new List <string>
{
"TKey"
},
Parameters = new List <IParameterDefinition>
{
new TestParameterDefinition
{
Type = "string"
},
new TestParameterDefinition
{
Type = "Guid"
},
new TestParameterDefinition
{
Type = "CancellationToken"
}
}
};
var newMethod = new TestMethodDefinition
{
RawName = oldMethod.RawName,
ReturnType = oldMethod.ReturnType,
GenericTypeParameters = new List <string>
{
"TKey",
"TValue"
},
Parameters = oldMethod.Parameters
};
var oldItems = new List <IMethodDefinition>
{
oldMethod
};
var newItems = new List <IMethodDefinition>
{
newMethod
};
var sut = new MethodEvaluator();
var actual = sut.FindMatches(oldItems, newItems);
actual.ItemsAdded.Should().BeEmpty();
actual.ItemsRemoved.Should().BeEmpty();
actual.MatchingItems.Should().HaveCount(1);
actual.MatchingItems.First().OldItem.Should().BeEquivalentTo(oldMethod);
actual.MatchingItems.First().NewItem.Should().BeEquivalentTo(newMethod);
}
public void FindMatchesReturnsEmptyWhenNoMethodsProvided()
{
var oldItems = Array.Empty <IMethodDefinition>();
var newItems = Array.Empty <IMethodDefinition>();
var sut = new MethodEvaluator();
var actual = sut.FindMatches(oldItems, newItems);
actual.ItemsAdded.Should().BeEmpty();
actual.ItemsRemoved.Should().BeEmpty();
actual.MatchingItems.Should().BeEmpty();
}
void SearchAndEval(ProblemDescriptor p, System.Reflection.Assembly[] assemblies, ProjectReport projectReport)
{
if (string.IsNullOrEmpty(p.customevaluator))
{
// try all assemblies. Need to find a way to only evaluate on the right assembly
foreach (var assembly in assemblies)
{
try
{
var value = MethodEvaluator.Eval(assembly.Location,
p.type, "get_" + p.method, new System.Type[0] {
}, new object[0] {
});
if (value.ToString() == p.value)
{
projectReport.AddIssue(new ProjectIssue
{
description = p.description,
category = IssueCategory.ProjectSettings,
descriptor = p
});
// stop iterating assemblies
break;
}
}
catch (Exception)
{
// this is safe to ignore
}
}
}
else
{
Type helperType = m_Helpers.GetType();
MethodInfo theMethod = helperType.GetMethod(p.customevaluator);
bool isIssue = (bool)theMethod.Invoke(m_Helpers, null);
if (isIssue)
{
projectReport.AddIssue(new ProjectIssue
{
description = p.description,
category = IssueCategory.ProjectSettings,
descriptor = p
});
}
}
}
ProjectIssue SearchAndEval(ProblemDescriptor descriptor)
{
if (string.IsNullOrEmpty(descriptor.customevaluator))
{
var paramTypes = new Type[] {};
var args = new object[] {};
var found = false;
// do we actually need to look in all assemblies? Maybe we can find a way to only evaluate on the right assembly
foreach (var assembly in m_Assemblies)
{
try
{
var value = MethodEvaluator.Eval(assembly.Location,
descriptor.type, "get_" + descriptor.method, paramTypes, args);
if (value.ToString() == descriptor.value)
{
return(NewIssue(descriptor, descriptor.description));
}
// Eval did not throw exception so we can stop iterating assemblies
found = true;
break;
}
catch (Exception)
{
// this is safe to ignore
}
}
if (!found)
{
Debug.Log(descriptor.method + " not found in any assembly");
}
}
else
{
var helperType = m_Helpers.GetType();
var theMethod = helperType.GetMethod(descriptor.customevaluator);
if ((bool)theMethod.Invoke(m_Helpers, null))
{
return(NewIssue(descriptor, descriptor.description));
}
}
return(null);
}
public void FindMatchesReturnsAllMethodsAsMatchesWhenNoChangesMade()
{
var oldItems = new List <IMethodDefinition>
{
new TestMethodDefinition(),
new TestMethodDefinition(),
new TestMethodDefinition(),
new TestMethodDefinition()
};
var newItems = new List <IMethodDefinition>(oldItems);
var sut = new MethodEvaluator();
var actual = sut.FindMatches(oldItems, newItems);
actual.ItemsAdded.Should().BeEmpty();
actual.ItemsRemoved.Should().BeEmpty();
actual.MatchingItems.Select(x => x.NewItem).Should().BeEquivalentTo(newItems);
actual.MatchingItems.Select(x => x.OldItem).Should().BeEquivalentTo(oldItems);
}
private void SearchAndEval(ProblemDescriptor descriptor, ProjectReport projectReport)
{
if (string.IsNullOrEmpty(descriptor.customevaluator))
{
// do we actually need to look in all assemblies? Maybe we can find a way to only evaluate on the right assembly
foreach (var assembly in m_Assemblies)
{
try
{
var value = MethodEvaluator.Eval(assembly.Location,
descriptor.type, "get_" + descriptor.method, new System.Type[0] {
}, new object[0] {
});
if (value.ToString() == descriptor.value)
{
AddIssue(descriptor, string.Format("{0}: {1}", descriptor.description, value), projectReport);
// stop iterating assemblies
break;
}
}
catch (Exception)
{
// this is safe to ignore
}
}
}
else
{
Type helperType = m_Helpers.GetType();
MethodInfo theMethod = helperType.GetMethod(descriptor.customevaluator);
bool isIssue = (bool)theMethod.Invoke(m_Helpers, null);
if (isIssue)
{
AddIssue(descriptor, descriptor.description, projectReport);
}
}
}
public static string Eval(string macro)
{
var ret = MethodEvaluator.ExecuteExternalCode(macro);
return(ret == null ? "Null" : ret.ToString());
}
public static IChangeCalculator BuildCalculator(ILogger?logger)
{
var attributeComparer = new AttributeComparer();
var attributeMatcher = new AttributeEvaluator();
var attributeProcessor = new AttributeMatchProcessor(attributeMatcher, attributeComparer, logger);
var accessModifierChangeTable = new AccessModifiersChangeTable();
var accessModifiersComparer = new AccessModifiersComparer(accessModifierChangeTable);
var memberModifiersChangeTable = new PropertyModifiersChangeTable();
var memberModifiersComparer = new PropertyModifiersComparer(memberModifiersChangeTable);
var genericTypeElementComparer = new GenericTypeElementComparer();
var fieldModifiersChangeTable = new FieldModifiersChangeTable();
var fieldModifiersComparer = new FieldModifiersComparer(fieldModifiersChangeTable);
var fieldComparer = new FieldComparer(accessModifiersComparer, fieldModifiersComparer, attributeProcessor);
var fieldMatcher = new FieldEvaluator();
var fieldProcessor = new FieldMatchProcessor(fieldMatcher, fieldComparer, logger);
var propertyAccessorAccessModifiersChangeTable = new PropertyAccessorAccessModifiersChangeTable();
var propertyAccessorAccessModifiersComparer = new PropertyAccessorAccessModifiersComparer(propertyAccessorAccessModifiersChangeTable);
var propertyAccessorComparer = new PropertyAccessorComparer(propertyAccessorAccessModifiersComparer, attributeProcessor);
var propertyAccessorEvaluator = new PropertyAccessorEvaluator();
var propertyAccessorProcessor =
new PropertyAccessorMatchProcessor(propertyAccessorEvaluator, propertyAccessorComparer, logger);
var propertyComparer = new PropertyComparer(accessModifiersComparer, memberModifiersComparer, propertyAccessorProcessor, attributeProcessor);
var propertyMatcher = new PropertyEvaluator();
var propertyProcessor = new PropertyMatchProcessor(propertyMatcher, propertyComparer, logger);
var methodEvaluator = new MethodEvaluator();
var methodModifiersChangeTable = new MethodModifiersChangeTable();
var methodModifiersComparer = new MethodModifiersComparer(methodModifiersChangeTable);
var parameterModifiersChangeTable = new ParameterModifiersChangeTable();
var parameterModifiersComparer = new ParameterModifiersComparer(parameterModifiersChangeTable);
var parameterComparer = new ParameterComparer(parameterModifiersComparer, attributeProcessor);
var methodComparer = new MethodComparer(accessModifiersComparer, methodModifiersComparer, genericTypeElementComparer, parameterComparer, attributeProcessor);
var methodProcessor = new MethodMatchProcessor(methodEvaluator, methodComparer, logger);
var classModifiersChangeTable = new ClassModifiersChangeTable();
var classModifiersComparer = new ClassModifiersComparer(classModifiersChangeTable);
var classComparer = new ClassComparer(
accessModifiersComparer,
classModifiersComparer,
genericTypeElementComparer,
fieldProcessor,
propertyProcessor,
methodProcessor, attributeProcessor);
var interfaceComparer = new InterfaceComparer(
accessModifiersComparer,
genericTypeElementComparer,
propertyProcessor,
methodProcessor,
attributeProcessor);
var structModifiersChangeTable = new StructModifiersChangeTable();
var structModifiersComparer = new StructModifiersComparer(structModifiersChangeTable);
var structComparer = new StructComparer(
accessModifiersComparer,
structModifiersComparer,
genericTypeElementComparer,
fieldProcessor,
propertyProcessor,
methodProcessor,
attributeProcessor);
var aggregateTypeComparer = new AggregateTypeComparer(classComparer, interfaceComparer, structComparer);
var typeEvaluator = new TypeEvaluator();
var typeProcessor = new TypeMatchProcessor(typeEvaluator, aggregateTypeComparer, logger);
return(new ChangeCalculator(typeProcessor, logger));
}
FindMatchesReturnsOverloadMethodAsMatchesWhenParametersMatchWithOtherOverloadRemoved()
{
var matchingOverload = new TestMethodDefinition
{
Parameters = new List <IParameterDefinition>
{
new TestParameterDefinition
{
Type = "List<string>"
},
new TestParameterDefinition
{
Type = "Guid"
},
new TestParameterDefinition
{
Type = "CancellationToken"
}
}
};
var otherOverload = new TestMethodDefinition
{
RawName = matchingOverload.RawName,
Parameters = new List <IParameterDefinition>
{
new TestParameterDefinition
{
Type = "string"
},
new TestParameterDefinition
{
Type = "Guid"
},
new TestParameterDefinition
{
Type = "CancellationToken"
}
}
};
var oldItems = new List <IMethodDefinition>
{
otherOverload,
matchingOverload
};
var newItems = new List <IMethodDefinition>
{
matchingOverload
};
var sut = new MethodEvaluator();
var actual = sut.FindMatches(oldItems, newItems);
actual.ItemsAdded.Should().BeEmpty();
actual.ItemsRemoved.Should().HaveCount(1);
actual.ItemsRemoved.First().Should().BeEquivalentTo(otherOverload);
actual.MatchingItems.Should().HaveCount(1);
actual.MatchingItems.First().OldItem.Should().BeEquivalentTo(matchingOverload);
actual.MatchingItems.First().NewItem.Should().BeEquivalentTo(matchingOverload);
}
