/// <summary>Executes the internal.</summary>
/// <param name="element">The element.</param>
protected override void Execute(IElement element)
{
var statement = this.Provider.GetSelectedElement<IExpressionStatement>(true, true);
if (statement == null)
{
return;
}
var factory = CSharpElementFactory.GetInstance(statement.GetPsiModule());
if (factory == null)
{
return;
}
var expression = statement.Expression;
if ((expression == null) || !(expression.ToTreeNode() is IUnaryExpressionNode))
{
return;
}
var type = expression.Type();
if (!type.IsResolved)
{
return;
}
var declaredType = type as IDeclaredType;
if (declaredType == null)
{
return;
}
var enumerate = declaredType.GetTypeElement() as IEnum;
if (enumerate == null)
{
return;
}
var typeName = enumerate.ShortName;
var code = new StringBuilder("switch(");
code.Append(statement.GetText());
code.Append(") {");
foreach (var field in enumerate.EnumMembers)
{
code.Append("case ");
code.Append(typeName);
code.Append('.');
code.Append(field.ShortName);
code.Append(":\r\nbreak;");
}
code.Append("default:\r\n");
code.Append("throw new System.ArgumentOutOfRangeException();");
code.Append("\r\n}");
var result = factory.CreateStatement(code.ToString());
if (result == null)
{
return;
}
result = statement.ReplaceBy(result);
var range = result.GetDocumentRange();
var codeFormatter = new CodeFormatter();
codeFormatter.Format(this.Solution, range);
}
/// <summary>
/// Inserts the assert.
/// </summary>
/// <param name="element">
/// The element.
/// </param>
/// <param name="anchor">
/// The anchor.
/// </param>
/// <param name="name">
/// The name.
/// </param>
private void CheckAssignment(IElement element, IStatement anchor, string name)
{
var functionDeclaration = anchor.GetContainingTypeMemberDeclaration() as IMethodDeclaration;
if (functionDeclaration == null)
{
return;
}
var body = functionDeclaration.Body;
if (body == null)
{
return;
}
var factory = CSharpElementFactory.GetInstance(element.GetPsiModule());
var csharpElement = element as ICSharpElement;
if (csharpElement == null)
{
return;
}
var code = string.Format("if({0} == null) {{ }}", name);
var statement = factory.CreateStatement(code);
var result = body.AddStatementAfter(statement, anchor);
var range = result.GetDocumentRange();
var codeFormatter = new CodeFormatter();
codeFormatter.Format(this.Solution, range);
}
/// <summary>Inserts the assert.</summary>
/// <param name="assertion">The assertion.</param>
/// <param name="element">The element.</param>
private void InsertAssertionCode(string assertion, IElement element)
{
IStatement anchor = null;
string name;
var assignmentExpression = element as IAssignmentExpression;
if (assignmentExpression != null)
{
anchor = assignmentExpression.GetContainingStatement();
var referenceExpression = assignmentExpression.Dest as IReferenceExpression;
if (referenceExpression == null)
{
return;
}
name = referenceExpression.Reference.GetName();
}
else
{
var treeNode = element.ToTreeNode();
while (treeNode != null)
{
anchor = treeNode as IStatement;
if (anchor != null)
{
break;
}
treeNode = treeNode.Parent;
}
var localVariable = element as ILocalVariable;
if (localVariable == null)
{
return;
}
name = localVariable.ShortName;
}
if (anchor == null)
{
return;
}
var functionDeclaration = anchor.GetContainingTypeMemberDeclaration() as IMethodDeclaration;
if (functionDeclaration == null)
{
return;
}
var body = functionDeclaration.Body;
if (body == null)
{
return;
}
var factory = CSharpElementFactory.GetInstance(element.GetPsiModule());
var csharpElement = element as ICSharpElement;
if (csharpElement == null)
{
return;
}
var code = string.Format(assertion, name);
var statement = factory.CreateStatement(code);
if (statement == null)
{
return;
}
var result = body.AddStatementAfter(statement, anchor);
var range = result.GetDocumentRange();
var codeFormatter = new CodeFormatter();
codeFormatter.Format(this.Solution, range);
}
/// <summary>Executes the parameters.</summary>
/// <param name="functionDeclaration">The function declaration.</param>
private void ExecuteFunction([NotNull] ICSharpFunctionDeclaration functionDeclaration)
{
if (this.IsAvailableGetterFunction(functionDeclaration))
{
this.ExecuteReturnValueAttribute(functionDeclaration);
}
var assertions = this.GetAssertions(functionDeclaration, true);
if (assertions.Count == 0)
{
return;
}
var factory = CSharpElementFactory.GetInstance(functionDeclaration.GetPsiModule());
var body = functionDeclaration.Body;
var codeFormatter = new CodeFormatter();
foreach (var assertion in assertions)
{
if (assertion.Nullable)
{
continue;
}
if (!assertion.NeedsStatement)
{
continue;
}
if (assertion.Statement != null)
{
body.RemoveStatement(assertion.Statement);
assertion.Statement = factory.CreateStatement(assertion.Statement.GetText());
continue;
}
if (string.IsNullOrEmpty(assertion.Code))
{
continue;
}
assertion.Statement = factory.CreateStatement(assertion.Code);
}
IStatement anchor = null;
if (body != null)
{
anchor = GetAnchor(body);
}
var hasAsserts = false;
foreach (var assertion in assertions)
{
if (assertion.Nullable)
{
continue;
}
this.MarkParameterWithAttribute(assertion);
if (body == null || assertion.Statement == null)
{
continue;
}
var result = body.AddStatementBefore(assertion.Statement, anchor);
CodeFormatter.Format(result);
hasAsserts = true;
}
if (anchor != null && hasAsserts)
{
this.InsertBlankLine(anchor, codeFormatter);
}
}
/// <summary>Generates the function assert statements.</summary>
/// <param name="classDeclaration">The class declaration.</param>
/// <param name="isPublic">if set to <c>true</c> [is public].</param>
private void ConvertToStringConstant(IClassDeclaration classDeclaration, bool isPublic)
{
var element = this.GetElementAtCaret();
if (element == null)
{
return;
}
var treeNode = element as ITreeNode;
if (treeNode == null)
{
return;
}
var expression = treeNode.Parent as ICSharpExpression;
if (expression == null)
{
return;
}
var factory = CSharpElementFactory.GetInstance(element.GetPsiModule());
if (factory == null)
{
return;
}
var text = treeNode.GetText();
var identifier = GetExistingIdentifier(classDeclaration, text);
if (string.IsNullOrEmpty(identifier))
{
identifier = this.GetIdentifier(classDeclaration, text);
var declarationText = string.Format("const string {0} = {1};", identifier, text);
if (isPublic)
{
declarationText = "public " + declarationText;
}
if (IntroduceStringConstantSettings.Instance.GenerateXmlComment)
{
declarationText = "/// <summary>" + text + "</summary>\r\n" + declarationText;
}
var classMemberDeclaration =
factory.CreateTypeMemberDeclaration(declarationText) as IClassMemberDeclaration;
if (classMemberDeclaration == null)
{
return;
}
var anchor = GetClassMemberAnchor(classDeclaration, identifier);
if (anchor != null)
{
classDeclaration.AddClassMemberDeclarationBefore(classMemberDeclaration, anchor);
}
else
{
classDeclaration.AddClassMemberDeclaration(classMemberDeclaration);
}
}
if (isPublic)
{
var qualifiedName = GetQualifiedClassDeclarationName(classDeclaration);
if (!string.IsNullOrEmpty(qualifiedName))
{
identifier = qualifiedName + "." + identifier;
}
}
var identifierExpression = factory.CreateExpression(identifier);
if (identifierExpression == null)
{
return;
}
var result = expression.ReplaceBy(identifierExpression);
var languageService = CSharpLanguageService.CSHARP.Service;
if (languageService == null)
{
return;
}
var formatter = languageService.CodeFormatter;
if (formatter == null)
{
return;
}
var range = result.GetDocumentRange();
var codeFormatter = new CodeFormatter();
codeFormatter.Format(this.Solution, range);
}
/// <summary>
/// Executes the internal.
/// </summary>
/// <param name="element">
/// The element.
/// </param>
protected override void Execute(IElement element)
{
if (string.IsNullOrEmpty(ValueAnalysisSettings.Instance.AllowNullAttribute))
{
return;
}
if (!this.IsAvailableInternal())
{
return;
}
var typeMemberDeclaration = this.GetTypeMemberDeclaration();
if (typeMemberDeclaration == null)
{
return;
}
var attributesOwnerDeclaration = typeMemberDeclaration as IAttributesOwnerDeclaration;
if (attributesOwnerDeclaration == null)
{
return;
}
var typeElement = GetAttribute(typeMemberDeclaration, ValueAnalysisSettings.Instance.AllowNullAttribute);
if (typeElement == null)
{
return;
}
var factory = CSharpElementFactory.GetInstance(typeMemberDeclaration.GetPsiModule());
var attribute = factory.CreateTypeMemberDeclaration("[" + ValueAnalysisSettings.Instance.AllowNullAttribute + "(\"*\")]void Foo(){}", new object[]
{
}).Attributes[0];
attribute = attributesOwnerDeclaration.AddAttributeAfter(attribute, null);
var name = attribute.TypeReference.GetName();
if (!name.EndsWith("Attribute"))
{
return;
}
/*
IReferenceName referenceName = factory.CreateReferenceName(name.Substring(0, name.Length - "Attribute".Length), new object[0]);
referenceName = attribute.Name.ReplaceBy(referenceName);
if (referenceName.Reference.Resolve().DeclaredElement != typeElement)
{
referenceName.Reference.BindTo(typeElement);
}
*/
var range = attribute.GetDocumentRange();
CodeFormatter codeFormatter = new CodeFormatter();
codeFormatter.Format(this.Solution, range);
}
/// <summary>
/// Executes this instance.
/// </summary>
/// <param name="solution">The solution.</param>
private void Execute(ISolution solution)
{
var returnStatement = this.warning.ReturnStatement;
var function = returnStatement.GetContainingTypeMemberDeclaration() as IFunction;
if (function == null)
{
return;
}
var type = function.ReturnType;
var rule = Rule.GetRule(type, function.Language) ?? Rule.GetDefaultRule();
if (rule == null)
{
return;
}
var code = rule.ReturnAssertion;
var expression = returnStatement.Value.GetText();
var typeName = type.GetLongPresentableName(returnStatement.Language);
code = "return " + string.Format(code, expression, typeName) + ";";
var factory = CSharpElementFactory.GetInstance(returnStatement.GetPsiModule());
var statement = factory.CreateStatement(code);
var result = returnStatement.ReplaceBy(statement);
var range = result.GetDocumentRange();
CodeFormatter codeFormatter = new CodeFormatter();
codeFormatter.Format(solution, range);
}
