public override ProblemCollection Check(Member member)
{
Method method = member as Method;
MetadataCollection <Instruction> enumerator = method.Instructions;
methodName = method.Name.ToString();
StatementCollection stmt = method.Body.Statements;
try
{
problemyn = false;
VisitStatements(stmt);
if (problemyn)
{
Resolution resolu = GetResolution(new string[] { method.ToString() + errorMessage });
Problems.Add(new Problem(resolu));
}
}
catch (Exception e)
{
Console.WriteLine(e);
}
return(Problems);
}
public override void VisitReturn(ReturnNode returnInstruction)
{
if (_problemRound && IsSqlGeneratingFunction(_currentMember))
{
if (returnInstruction.Expression != null && IsStringIsh(returnInstruction.Expression.Type) && !IsConst(returnInstruction.Expression) && !_dirty.IsSafe(returnInstruction.Expression))
{
if (!_params.Contains(returnInstruction.Expression.UniqueKey) || _dirty.MarkedDirtyInsideMethod(returnInstruction.Expression)) //if the return IS a param, then it's also got to be marked dirty inside the method (like if you pass a SQL builder in, append stuff to it, and then return it back out)
{
Problems.Add(new Problem(this.GetResolution(returnInstruction.Expression.GetName(), _dirty.GetDirtyDetails(returnInstruction.Expression, returnInstruction, true)), returnInstruction.SourceContext));
}
}
var currentMethod = _currentMember as Method;
foreach (var p in currentMethod.Parameters.Where(w => !IsTypeSafe(w.Type)))
{
//if it's been marked dirty (aside from being a param), DANGER!
if (_dirty.MarkedDirtyInsideMethod(p))
{
Problems.Add(new Problem(this.GetResolution(p.GetName(), _dirty.GetDirtyDetails(p, returnInstruction, false)), returnInstruction.SourceContext));
}
}
}
base.VisitReturn(returnInstruction);
}
public override ProblemCollection Check(ModuleNode node)
{
var assemblyNode = node as AssemblyNode;
if (assemblyNode != null)
{
var assemblyAvailableResources = new HashSet <PropertyNode>();
var assemblyUsedResources = new HashSet <PropertyNode>();
_availableResources[assemblyNode] = assemblyAvailableResources;
_usedResources[assemblyNode] = assemblyUsedResources;
VisitAssembly(assemblyNode);
IEnumerable <PropertyNode> unusedResources = from res in assemblyAvailableResources.Except(assemblyUsedResources)
where !IsCommonResource(res)
select res;
foreach (PropertyNode item in unusedResources)
{
Problems.Add(new Problem(this.GetResolution(item.Name.Name, item.DeclaringType.FullName), item.UniqueKey.ToString()));
}
}
return(Problems);
}
private void CheckMethod(Method method)
{
if (method == null ||
method.FullName.Equals(RegionEndpointStaticConstructorName) ||
method.Instructions == null ||
method.Instructions.Count == 0)
{
return;
}
foreach (var instruction in method.Instructions)
{
var field = instruction.Value as Field;
if (field != null &&
field.FullName.StartsWith(RegionEndpointFieldNamePrefix) &&
field.Type.FullName.Equals(RegionEndpointTypeName))
{
var suppressionTarget = method.DeclaringType.FullName + ".#" + method.Name.Name + "(" + string.Join(",", method.Parameters.Select(p => p.Type.FullName).ToArray()) + ")";
Resolution resolution;
if (field.FullName.EndsWith(USEast1EndpointName))
{
resolution = GetResolution(suppressionTarget, field.FullName, "shouldn't usually", USEast1ResolutionMessage);
}
else
{
resolution = GetResolution(suppressionTarget, field.FullName, "should never", "");
}
Problems.Add(new Problem(resolution));
}
}
}
public override ProblemCollection Check(Member member)
{
var method = member as Method;
if (method == null)
{
// This rule only applies to fields.
// Return a null ProblemCollection so no violations are reported for this member.
return(null);
}
if (method.FullName.EndsWith(".Finalize"))
{
bool disposeFound = method.Instructions.Any(p => p.Value is Method && (p.Value as Method).FullName.EndsWith(".Dispose(System.Boolean)"));
if (!disposeFound)
{
Resolution resolution = GetResolution(method);
var problem = new Problem(resolution);
Problems.Add(problem);
}
return(Problems);
}
return(Problems);
}
private void AddProblem(SourceContext sourceContext, Identifier parameterName)
{
var resolution = GetResolution(parameterName.Name);
var problem = new Problem(resolution, sourceContext, CheckId);
Problems.Add(problem);
}
public override ProblemCollection Check(TypeNode typeNode)
{
if (typeNode.Interfaces.Any())
{
InterfaceNode foundServiceInterface = typeNode.Interfaces.First(i => i.FullName.EndsWith(".IBaseService"));
if (foundServiceInterface != null)
{
bool foundUsage = false;
TypeNode serviceManagerTypeNode = foundServiceInterface.DeclaringModule.Types.First(t => t.FullName.EndsWith(".ServiceManager"));
if (serviceManagerTypeNode != null)
{
Member member = serviceManagerTypeNode.Members.First(t => t.FullName.EndsWith(".RegisterAllServices"));
var method = member as Method;
if (method != null)
{
foundUsage = method.Instructions.Any(opcode => opcode.Value != null && opcode.Value.ToString().Contains(typeNode.FullName + "("));
}
}
if (!foundUsage)
{
Resolution resolution = GetResolution(typeNode.FullName);
var problem = new Problem(resolution);
Problems.Add(problem);
}
}
}
return(Problems);
}
public void CreateProblem(string text)
{
var newProblem = new CreateProblemContainer(SqliteDb.GetInstance(), text, true).Container;
Problems.Add(newProblem);
CurrentProblem = newProblem;
}
public override ProblemCollection Check(TypeNode type)
{
if (type == null)
{
return(Problems);
}
if (!IsPresenterImplementation(type))
{
return(Problems);
}
if (!type.Name.Name.EndsWith("Presenter", StringComparison.Ordinal))
{
Problems.Add(new Problem(
GetResolution(type.FullName))
{
Certainty = 100,
FixCategory = FixCategories.Breaking,
MessageLevel = MessageLevel.Warning
});
}
return(Problems);
}
public override ProblemCollection Check(Member member)
{
Field field = member as Field;
if (field == null)
{
// This rule only applies to fields.
// Return a null ProblemCollection so no violations are reported for this member.
return(null);
}
string actualType = field.Type.FullName;
if (actualType == "SamplesForCodeAnalysis.ILog")
{
if (!field.IsStatic)
{
Resolution resolution = GetResolution(field, actualType);
Problem problem = new Problem(resolution);
Problems.Add(problem);
}
}
return(Problems);
}
public override ProblemCollection Check(Member member)
{
Method method = member as Method;
bool boolFoundConnectionOpened = false;
bool boolFoundConnectionClosed = false;
Instruction objInstr = null;
if (method != null)
{
for (int i = 0; i < method.Instructions.Count; i++)
{
objInstr = method.Instructions[i];
if (objInstr.Value != null)
{
if (objInstr.Value.ToString().Contains("System.Data.SqlClient.SqlConnection"))
{
boolFoundConnectionOpened = true;
}
if (boolFoundConnectionOpened)
{
if (objInstr.Value.ToString().Contains("System.Data.Common.DbConnection.Close"))
{
boolFoundConnectionClosed = true;
}
}
}
}
}
if ((boolFoundConnectionOpened) && (boolFoundConnectionClosed == false))
{
Resolution resolu = GetResolution(new string[] { method.ToString() });
Problems.Add(new Problem(resolu));
}
return(Problems);
}
/// <inheritdoc />
public override void VisitBinaryExpression(BinaryExpression binaryExpression)
{
var operand1 = binaryExpression.Operand1 as BinaryExpression;
if (operand1 == null)
{
var isEqual = binaryExpression.NodeType == NodeType.Ceq;
var isLessThan = binaryExpression.NodeType == NodeType.Clt;
var isGreaterThan = binaryExpression.NodeType == NodeType.Cgt;
if (isEqual || isLessThan || isGreaterThan)
{
if (IsCountAndZeroOperation(binaryExpression))
{
Problems.Add(CreateProblem(binaryExpression));
}
}
}
else
{
var isNotEqual = operand1.NodeType == NodeType.Ceq;
var isLessThanEqual = operand1.NodeType == NodeType.Cgt;
var isGreaterThanEqual = operand1.NodeType == NodeType.Clt;
if (isNotEqual || isLessThanEqual || isGreaterThanEqual)
{
if (IsCountAndZeroOperation(operand1))
{
Problems.Add(CreateProblem(binaryExpression));
}
}
}
}
public void When(RegistrationFailed c)
{
foreach (var problem in c.Problems)
{
Problems.Add(problem);
}
}
private void CheckForLongMethod(Method method)
{
if (CreateMetrics().Calculate(method) > 10)
{
string[] resolutionParams = { method.FullName };
Problems.Add(new Problem(new Resolution("Method {0} is too long", resolutionParams)));
}
}
private void CheckParamsLength(Method method)
{
if (method.Parameters.Count > 3)
{
string[] resolutionParams = { method.FullName };
Problems.Add(new Problem(new Resolution("Method {0} has too many parameters", resolutionParams)));
}
}
private void CheckType(TypeNode type, Member member)
{
if (IsAssignableTo(type, MD5Type))
{
var resolution = GetResolution(type, member.FullName);
Problems.Add(new Problem(resolution));
}
}
public override ProblemCollection Check(Member member)
{
if (member.IsControllerAction() && !member.HasActionMethodSelectorAttribute())
{
Problems.Add(new Problem(this.GetResolution()));
}
return(Problems);
}
public override ProblemCollection Check(Member member)
{
if (member.IsControllerAction() && member.Attributes.Any(a => a.Type.FullName == "CDS.Web.Authorization.SkipAuthorizeAttribute"))
{
Problems.Add(new Problem(this.GetResolution()));
}
return(Problems);
}
public void AddProblem(string problem)
{
if (null == Problems)
{
Problems = new List <string>();
}
Problems.Add(problem);
}
private void CheckLongIdentifier(Identifier identifier)
{
if (identifier.Name.Length > 20 & !(identifier.Name.Contains("<") || (identifier.Name.Contains("$"))))
{
string[] resolutionParams = { identifier.Name };
Problems.Add(new Problem(new Resolution("Identifier {0} has more than 20 characters", resolutionParams), _currentNode));
}
}
private void CheckStatic(TypeNode containerType, TypeNode typeOfStatic)
{
if (ImplementsILogger(typeOfStatic))
{
var resolution = GetResolution(containerType, typeOfStatic, LoggerInterfaceFullName);
Problems.Add(new Problem(resolution));
}
}
private void CheckCollaborators(TypeNode type)
{
if (CreateCollabCount().Calculate(type) > 3)
{
string[] resolutionParams = { type.FullName };
Problems.Add(new Problem(new Resolution("Type {0} has more than 3 collaborators", resolutionParams), type));
}
}
public void AddProblem(ProblemMetadata problemMetadata)
{
ArgumentUtility.CheckNotNull("problemMetadata", problemMetadata);
var resolution = GetResolution(problemMetadata.ExpectedFragment, problemMetadata.GivenFragment);
var problem = new Problem(resolution, problemMetadata.SourceContext, CheckId);
Problems.Add(problem);
}
public T RequiresComponent <T>(string expectedLocation = null) where T : Component
{
if (!Entity.TryGetComponentInChildren(out T component))
{
Problems.Add(new MissingComponent(Entity, typeof(T), of, expectedLocation));
}
return(component);
}
private void CheckForLargeClass(TypeNode type)
{
if (MethodCount(type) > 8)
{
string[] resolutionParams = { type.FullName };
Problems.Add(new Problem(new Resolution("Type {0} has too many methods/properties", resolutionParams)));
}
}
public async Task <bool> LoadAsync()
{
if (string.IsNullOrEmpty(Path))
{
return(false);
}
try
{
FileStream fs = new FileStream(Path, FileMode.Open, FileAccess.Read);
byte[] data = new byte[fs.Length];
await fs.ReadAsync(data, 0, data.Length).ConfigureAwait(false);
List <ProblemViewModel> ps = new List <ProblemViewModel>();
data = DocumentHelper.UnpackData(data);
if (data == null)
{
return(false);
}
MemoryStream ms = new MemoryStream(data);
while (ms.Position < ms.Length)
{
ProblemViewModel problem = null;
Dispatcher.BeginInvoke((Action)(() => {
problem = ProblemViewModel.CreateFromStream(ms);
})).Wait();
if (problem == null)
{
return(false);
}
if (!await Task.Factory.StartNew(() =>
{
if (problem == null || !problem.Load(ms))
{
return(false);
}
return(true);
}).ConfigureAwait(false))
{
return(false);
}
ps.Add(problem);
}
ms.Close();
Dispatcher.BeginInvoke((Action)(() => {
Problems.Clear();
foreach (var problem in ps)
{
Problems.Add(problem);
}
}));
IsDirty = false;
return(true);
}
catch (Exception)
{
return(false);
}
}
public override ProblemCollection Check(Member member)
{
if (member.NodeType == NodeType.Method && member.Name.Name == "Finalize")
{
Problems.Add(new Problem(GetResolution(member.DeclaringType.FullName), member));
}
return(Problems);
}
/// <inheritdoc />
public override void VisitAssignmentStatement(AssignmentStatement assignment)
{
base.VisitAssignmentStatement(assignment);
if (IsDefaultValue(assignment.Target.Type, assignment.Source))
{
Problems.Add(CreateProblem(assignment));
}
}
public static TrafficProblem NewRoad(string reasonName)
{
TrafficProblem problem = new TrafficProblem(reasonName);
Problems.Add(problem);
Save();
return(problem);
}
/// <inheritdoc />
public override ProblemCollection Check(TypeNode type)
{
if (type.IsAssignableTo(FrameworkTypes.Exception) && type.IsAbstract == false && RuleUtilities.IsSerializable(type) == false)
{
Problems.Add(new Problem(GetResolution(type.Name.Name)));
}
return(Problems);
}
