/// <summary>
/// Rewrites the return statement.
/// </summary>
/// <param name="returnStatement"></param>
public override IStatement Rewrite(IReturnStatement returnStatement)
{
Contract.Ensures(Contract.Result <IStatement>() != null);
var blockStmt = new BlockStatement();
// If local is null it means that the type of the method that contains this return is 'void'
if (local != null)
{
blockStmt.Statements.Add(new ExpressionStatement
{
Expression = new Assignment
{
Target = new TargetExpression {
Definition = local.LocalVariable, Instance = null, Type = local.LocalVariable.Type
},
Source = Rewrite(returnStatement.Expression),
Type = returnStatement.Expression.Type
}
});
}
blockStmt.Statements.Add(new GotoStatement {
TargetStatement = target
});
return(blockStmt);
}
public static bool IsReturnTypeIObservable(IReturnStatement returnStatement)
{
try
{
var type = returnStatement.Value.GetExpressionType().ToIType();
if (type == null)
{
return false;
}
var scalarType = type.GetScalarType();
if (scalarType == null)
{
return false;
}
return scalarType.GetClrName().FullName == Constants.ObservableInterfaceName ||
TypeHelper.HasIObservableSuperType(scalarType);
}
catch (Exception exn)
{
Debug.WriteLine(exn);
return false;
}
}
public override void VisitReturnStatement(IReturnStatement operation)
{
LogString(nameof(IReturnStatement));
LogCommonPropertiesAndNewLine(operation);
base.VisitReturnStatement(operation);
}
public static bool IsReturnTypeAsObservable(IReturnStatement returnStatement)
{
try
{
var invocationExpression = returnStatement.Value as IInvocationExpression;
if (invocationExpression == null)
{
return false;
}
var invokedExpression = invocationExpression.InvokedExpression as IReferenceExpression;
if (invokedExpression == null)
{
return false;
}
var resolveResult = invokedExpression.Reference.Resolve();
var declaredElement = resolveResult.DeclaredElement;
if (declaredElement == null)
{
return false;
}
return declaredElement.ShortName == Constants.AsObservableName;
}
catch (Exception exn)
{
Debug.WriteLine(exn);
return false;
}
}
public override void VisitYieldBreakStatement(IReturnStatement operation)
{
LogString("YieldBreakStatement");
LogCommonPropertiesAndNewLine(operation);
base.VisitYieldBreakStatement(operation);
}
public override void VisitReturnStatement <TExpression>(IReturnStatement <TExpression> returnStatement)
{
Value = new Statement()
{
ReturnStatement = new ReturnStatementFactory(returnStatement).Value
};
}
public static bool IsReturnTypeOnlyIObservable(IReturnStatement returnStatement)
{
try
{
var type = returnStatement.Value.GetExpressionType().ToIType();
if (type == null)
{
return false;
}
var scalarType = type.GetScalarType();
if (scalarType == null)
{
return false;
}
if (scalarType.GetClrName().FullName == Constants.ObservableInterfaceName)
{
if (scalarType.GetSuperTypes().Count() == 1 &&
scalarType.GetSuperTypes().First().GetClrName().FullName == Constants.ObjectName)
{
return true;
}
}
return false;
}
catch (Exception exn)
{
Debug.WriteLine(exn);
return false;
}
}
public override IStatement Visit(IReturnStatement stmt, int context)
{
return(new ReturnStatement
{
Expression = Anonymize(stmt.Expression)
});
}
public override void VisitReturnStatement <TExpression>(IReturnStatement <TExpression> returnStatement)
{
Steps.Add(new WriteReturnKeyword());
Steps.Add(new WriteWhitespace());
Steps.Add(new WriteExpression <TExpression>(returnStatement.Expression));
Steps.Add(new WriteSemicolon());
}
/// <summary>
///
/// </summary>
public override void TraverseChildren(IReturnStatement returnStatement)
{
Bpl.IToken tok = returnStatement.Token();
if (returnStatement.Expression != null)
{
ExpressionTraverser etrav = this.factory.MakeExpressionTraverser(this.sink, this, this.contractContext);
etrav.Traverse(returnStatement.Expression);
if (this.sink.ReturnVariable == null || etrav.TranslatedExpressions.Count < 1)
{
throw new TranslationException(String.Format("{0} returns a value that is not supported by the function", returnStatement.ToString()));
}
StmtBuilder.Add(Bpl.Cmd.SimpleAssign(tok,
new Bpl.IdentifierExpr(tok, this.sink.ReturnVariable), etrav.TranslatedExpressions.Pop()));
}
// FEEDBACK TODO extract into a method
if (PhoneCodeHelper.instance().PhoneFeedbackToggled)
{
IMethodDefinition methodTranslated = sink.getMethodBeingTranslated();
if (methodTranslated != null && PhoneCodeHelper.instance().isMethodInputHandlerOrFeedbackOverride(methodTranslated) &&
!PhoneCodeHelper.instance().isMethodIgnoredForFeedback(methodTranslated))
{
Bpl.AssertCmd falseAssertion = new Bpl.AssertCmd(Bpl.Token.NoToken, Bpl.LiteralExpr.False);
StmtBuilder.Add(falseAssertion);
}
}
StmtBuilder.Add(new Bpl.ReturnCmd(returnStatement.Token()));
}
private void AnalyzeReturnStatement([NotNull] IReturnStatement returnStatement, OperationBlockAnalysisContext context,
[NotNull] IDictionary <ILocalSymbol, EvaluationResult> variableEvaluationCache)
{
if (!ReturnsConstant(returnStatement) && !IsYieldBreak(returnStatement))
{
AnalyzeReturnValue(returnStatement, context, variableEvaluationCache);
}
}
public override void Visit(IReturnStatement returnStatement)
{
if (Process(returnStatement))
{
visitor.Visit(returnStatement);
}
base.Visit(returnStatement);
}
public void Analyze([NotNull] IReturnStatement returnStatement)
{
EvaluationResult result = AnalyzeExpression(returnStatement.ReturnedValue);
if (result.IsConclusive && result.IsDeferred)
{
ReportDiagnosticAt(returnStatement, result.DeferredOperationName);
}
}
public override void VisitReturnStatement(IReturnStatement returnStatementParam)
{
ICSharpExpression csharpExpression = returnStatementParam.Value;
expressionTypes.Add(csharpExpression != null
? csharpExpression.GetExpressionType(resolveContext)
: returnStatementParam.GetPsiModule().GetPredefinedType().Void);
base.VisitReturnStatement(returnStatementParam);
}
public override void VisitReturnStatement(IReturnStatement returnStatementParam)
{
ICSharpExpression csharpExpression = returnStatementParam.Value;
expressionTypes.Add(csharpExpression != null
? csharpExpression.GetExpressionType(resolveContext)
: returnStatementParam.GetPsiModule().GetPredefinedType().Void);
base.VisitReturnStatement(returnStatementParam);
}
public override void Visit(IReturnStatement ret)
{
if (ret.Expression != null && !Names.AnonymousDelegateReturns.Contains(ret))
{
returns.Add(ret);
var expanded = new HashSet <string>(Names.Names(Expand(ret.Expression)));
expanded.Add("return");
Mark(expanded);
}
}
private void AnalyzeReturnValue([NotNull] IReturnStatement returnStatement, OperationBlockAnalysisContext context,
[NotNull] IDictionary <ILocalSymbol, EvaluationResult> variableEvaluationCache)
{
EvaluationResult result = AnalyzeExpression(returnStatement.ReturnedValue, context.OperationBlocks,
variableEvaluationCache, context.CancellationToken);
if (result.IsConclusive && result.IsDeferred)
{
ReportDiagnosticAt(returnStatement, result.DeferredOperationName, context);
}
}
public override void TraverseChildren(IReturnStatement returnStatement)
{
this.PrintToken(VBToken.Indent);
this.PrintToken(VBToken.Return);
if (returnStatement.Expression != null)
{
this.PrintToken(VBToken.Space);
this.Traverse(returnStatement.Expression);
}
this.PrintToken(VBToken.NewLine);
}
public override bool Visit(IReturnStatement statement, IStatement context)
{
_stack.Push(statement);
try
{
return(base.Visit(statement, context));
}
finally
{
_stack.Pop();
}
}
public void Visit(IReturnStatement stmt, SSTPrintingContext c)
{
c.Indentation().Keyword("return");
if (!stmt.IsVoid)
{
c.Space();
stmt.Expression.Accept(this, c);
}
c.Text(";");
}
private void ReportDiagnosticAt([NotNull] IReturnStatement returnStatement, [NotNull] string operationName)
{
Location location = returnStatement.GetLocationForKeyword();
ISymbol containingMember = context.OwningSymbol.GetContainingMember();
string memberName = containingMember.ToDisplayString(SymbolDisplayFormat.CSharpShortErrorMessageFormat);
Diagnostic diagnostic = operationName == QueryOperationName
? Diagnostic.Create(QueryRule, location, containingMember.Kind, memberName)
: Diagnostic.Create(OperationRule, location, containingMember.Kind, memberName, operationName);
context.ReportDiagnostic(diagnostic);
}
private static Location GetLocationForReturnOrYield([NotNull] IReturnStatement operation)
{
if (operation.Syntax is ReturnStatementSyntax returnSyntax)
{
return(returnSyntax.ReturnKeyword.GetLocation());
}
if (operation.Syntax is YieldStatementSyntax yieldSyntax)
{
return(GetLocationForYieldStatement(yieldSyntax));
}
throw ExceptionFactory.Unreachable();
}
private void ProcessReturnStatement(IReturnStatement pStatement)
{
if (mCurrentBlock.Terminated)
{
mCurrentBlock = CreateBlock(CreateLabel());
}
HLLocation locationExpression = null;
if (pStatement.Expression != null)
{
locationExpression = ProcessExpression(pStatement.Expression);
}
mCurrentBlock.EmitReturn(locationExpression);
}
/// <summary>
/// Analyzes the return statement.
/// </summary>
/// <param name="returnStatement">
/// The return statement.
/// </param>
/// <returns>
/// </returns>
public IEnumerable<SuggestionBase> AnalyzeReturnStatement(IReturnStatement returnStatement)
{
var suggestions = new List<SuggestionBase>();
if (returnStatement.Value == null)
{
return suggestions;
}
if (this.RequiresAssertion(returnStatement))
{
suggestions.Add(new ReturnWarning(this.solution, returnStatement));
}
return suggestions;
}
private static Location GetLocationForReturnOrYield([NotNull] IReturnStatement operation)
{
var returnSyntax = operation.Syntax as ReturnStatementSyntax;
if (returnSyntax != null)
{
return(returnSyntax.ReturnKeyword.GetLocation());
}
var yieldSyntax = operation.Syntax as YieldStatementSyntax;
if (yieldSyntax != null)
{
return(GetLocationForYieldStatement(yieldSyntax));
}
throw ExceptionFactory.Unreachable();
}
public override IStatement Rewrite(IReturnStatement returnStatement)
{
if (returnStatement.Expression == null)
{
return new GotoStatement()
{
TargetStatement = this.newExit,
}
}
;
List <IStatement> stmts = new List <IStatement>();
stmts.Add(MakeAssignmentStatement(this.result, returnStatement.Expression, returnStatement.Locations));
stmts.Add(new GotoStatement()
{
TargetStatement = newExit
});
return(new BlockStatement()
{
Statements = stmts
});
}
/// <summary>
///
/// </summary>
public override void TraverseChildren(IReturnStatement returnStatement)
{
Bpl.IToken tok = returnStatement.Token();
if (returnStatement.Expression != null)
{
ExpressionTraverser etrav = this.factory.MakeExpressionTraverser(this.sink, this, this.contractContext);
etrav.Traverse(returnStatement.Expression);
if (this.sink.ReturnVariable == null || etrav.TranslatedExpressions.Count < 1)
{
throw new TranslationException(String.Format("{0} returns a value that is not supported by the function", returnStatement.ToString()));
}
var returnExprBpl = etrav.TranslatedExpressions.Pop();
AddRecordCall("<return value>", returnStatement.Expression, returnExprBpl);
StmtBuilder.Add(Bpl.Cmd.SimpleAssign(tok,
new Bpl.IdentifierExpr(tok, this.sink.ReturnVariable), returnExprBpl));
}
StmtBuilder.Add(new Bpl.ReturnCmd(returnStatement.Token()));
}
/// <summary>
/// Traverses the return statement.
/// </summary>
public void Traverse(IReturnStatement returnStatement)
{
Contract.Requires(returnStatement != null);
if (this.preorderVisitor != null) this.preorderVisitor.Visit(returnStatement);
if (this.StopTraversal) return;
this.TraverseChildren(returnStatement);
if (this.StopTraversal) return;
if (this.postorderVisitor != null) this.postorderVisitor.Visit(returnStatement);
}
/// <summary>
/// Traverses the return statement.
/// </summary>
public virtual void TraverseChildren(IReturnStatement returnStatement)
{
Contract.Requires(returnStatement != null);
this.TraverseChildren((IStatement)returnStatement);
if (this.StopTraversal) return;
if (returnStatement.Expression != null)
this.Traverse(returnStatement.Expression);
}
public override void TraverseChildren(IReturnStatement returnStatement) {
this.PrintToken(CSharpToken.Indent);
this.PrintToken(CSharpToken.Return);
if (returnStatement.Expression != null) {
this.PrintToken(CSharpToken.Space);
this.Traverse(returnStatement.Expression);
}
this.PrintToken(CSharpToken.Semicolon);
this.PrintToken(CSharpToken.NewLine);
}
/// <summary>
/// Performs some computation with the return statement.
/// </summary>
/// <param name="returnStatement"></param>
public virtual void Visit(IReturnStatement returnStatement)
{
}
public override void VisitReturnStatement(IReturnStatement operation)
{
base.VisitReturnStatement(operation);
}
public virtual void VisitReturnStatement(IReturnStatement operation)
{
DefaultVisit(operation);
}
/// <summary>
/// Rewrites the return statement.
/// </summary>
/// <param name="returnStatement"></param>
public virtual IStatement Rewrite(IReturnStatement returnStatement)
{
return returnStatement;
}
public void Visit(IReturnStatement returnStatement)
{
Contract.Requires(returnStatement != null);
throw new NotImplementedException();
}
/// <summary>
/// Returns a shallow copy of the return statement.
/// </summary>
/// <param name="returnStatement"></param>
public ReturnStatement Copy(IReturnStatement returnStatement) {
Contract.Requires(returnStatement != null);
Contract.Ensures(Contract.Result<ReturnStatement>() != null);
return new ReturnStatement(returnStatement);
}
public override void VisitReturnStatement(IReturnStatement operation)
{
base.VisitReturnStatement(operation);
}
/// <summary>
/// Visits the return statement.
/// </summary>
/// <param name="returnStatement">The return statement.</param>
/// <param name="consumer">The consumer.</param>
/// <returns></returns>
public override object VisitReturnStatement(IReturnStatement returnStatement, IHighlightingConsumer consumer)
{
AddHighlighting(consumer, this.returnAnalyzer.AnalyzeReturnStatement(returnStatement));
return base.VisitReturnStatement(returnStatement, consumer);
}
/// <summary>
/// Returns a deep copy of the return statement.
/// </summary>
/// <param name="returnStatement"></param>
public ReturnStatement Copy(IReturnStatement returnStatement) {
Contract.Requires(returnStatement != null);
Contract.Ensures(Contract.Result<ReturnStatement>() != null);
var mutableCopy = this.shallowCopier.Copy(returnStatement);
if (mutableCopy.Expression != null)
mutableCopy.Expression = this.Copy(mutableCopy.Expression);
return mutableCopy;
}
/// <summary>
/// Initializes a new instance of the <see cref="ReturnWarning"/> class.
/// </summary>
/// <param name="solution">
/// The solution.
/// </param>
/// <param name="returnStatement">
/// The return statement.
/// </param>
public ReturnWarning(ISolution solution, IReturnStatement returnStatement)
: base(Name, returnStatement, GetRange(returnStatement), "Return value should be asserted [Agent Johnson]")
{
this.returnStatement = returnStatement;
}
public void Visit(IReturnStatement returnStatement)
{
this.traverser.Traverse(returnStatement);
}
/// <summary>
/// Determines whether this instance is asserted.
/// </summary>
/// <param name="returnStatement">
/// The return statement.
/// </param>
/// <returns>
/// <c>true</c> if this instance is asserted; otherwise, <c>false</c>.
/// </returns>
private bool RequiresAssertion(IReturnStatement returnStatement)
{
var canBeNullName = CodeAnnotationsCache.CanBeNullAttributeShortName;
if (string.IsNullOrEmpty(canBeNullName))
{
return false;
}
var notNullName = CodeAnnotationsCache.NotNullAttributeShortName;
if (string.IsNullOrEmpty(notNullName))
{
return false;
}
var value = returnStatement.Value;
if (value.IsConstantValue())
{
return false;
}
var returnValue = value.GetText();
if (returnValue == "string.Empty" || returnValue == "String.Empty" || returnValue == "null")
{
return false;
}
if (!(value is ICreationExpression))
{
return false;
}
var function = returnStatement.GetContainingTypeMemberDeclaration() as IFunction;
if (function == null)
{
return false;
}
var type = function.ReturnType;
if (!type.IsReferenceType())
{
return false;
}
if (this.HasAnnotation(function))
{
return false;
}
var rule = Rule.GetRule(type, function.Language) ?? Rule.GetDefaultRule();
if (rule == null)
{
return false;
}
if (string.IsNullOrEmpty(rule.ReturnAssertion))
{
return false;
}
var isAsserted = this.GetIsAsserted(returnStatement);
if (isAsserted)
{
return false;
}
return GetValueAnalysis(returnStatement, function);
}
/// <summary>
/// Performs some computation with the return statement.
/// </summary>
/// <param name="returnStatement"></param>
public virtual void Visit(IReturnStatement returnStatement)
{
this.Visit((IStatement)returnStatement);
}
public override void TraverseChildren(IReturnStatement returnStatement)
{ MethodEnter(returnStatement);
base.TraverseChildren(returnStatement);
MethodExit(); }
public void Visit(IReturnStatement returnStatement)
{
throw new NotImplementedException();
}
/// <summary>
/// Gets the is asserted.
/// </summary>
/// <param name="returnStatement">
/// The return statement.
/// </param>
/// <returns>
/// Returns the boolean.
/// </returns>
private bool GetIsAsserted(IReturnStatement returnStatement)
{
var invocationExpression = returnStatement.Value as IInvocationExpression;
if (invocationExpression == null)
{
return false;
}
var invokedExpression = invocationExpression.InvokedExpression as IReferenceExpression;
if (invokedExpression == null)
{
return false;
}
var resolveResult = invokedExpression.Reference.Resolve();
IMethod method = null;
var methodDeclaration = resolveResult.DeclaredElement as IMethodDeclaration;
if (methodDeclaration != null)
{
method = methodDeclaration.DeclaredElement;
}
if (method == null)
{
method = resolveResult.DeclaredElement as IMethod;
}
if (method == null)
{
return false;
}
var codeAnnotationsCache = CodeAnnotationsCache.GetInstance(this.solution);
return codeAnnotationsCache.IsAssertionMethod(method);
}
public virtual void VisitYieldBreakStatement(IReturnStatement operation)
{
DefaultVisit(operation);
}
//^ ensures this.path.Count == old(this.path.Count);
/// <summary>
/// Traverses the return statement.
/// </summary>
/// <param name="returnStatement"></param>
public virtual void Visit(IReturnStatement returnStatement)
{
if (this.stopTraversal) return;
//^ int oldCount = this.path.Count;
this.path.Push(returnStatement);
if (returnStatement.Expression != null)
this.Visit(returnStatement.Expression);
//^ assume this.path.Count == oldCount+1; //True because all of the virtual methods of this class promise not decrease this.path.Count.
this.path.Pop();
}
public virtual void VisitReturnStatement <TExpression>(IReturnStatement <TExpression> returnStatement)
where TExpression : IExpression
{
Visit(returnStatement);
}
/// <summary>
///
/// </summary>
/// <param name="returnStatement"></param>
public ReturnStatement(IReturnStatement returnStatement)
: base(returnStatement) {
this.expression = returnStatement.Expression;
}
public virtual void VisitReturnStatement(IReturnStatement s)
{
}
public virtual void onASTElement(IReturnStatement returnStatement) { }
/// <summary>
/// Visits the specified return statement.
/// </summary>
/// <param name="returnStatement">The return statement.</param>
public override void Visit(IReturnStatement returnStatement)
{
ReturnStatement mutableReturnStatement = new ReturnStatement(returnStatement);
this.resultStatement = this.myCodeCopier.DeepCopy(mutableReturnStatement);
}
/// <inheritdoc />
public override Expression VisitYieldBreakStatement(IReturnStatement operation, LocalBinder argument)
{
return Expression.Break()
}
public ReturnStatementCompiler(IReturnStatement node, AbstractILCompilerParams myParams) : base(myParams)
{
myReturnStatement = node;
}
/// <summary>
/// Returns a deep copy of the return statement.
/// </summary>
/// <param name="returnStatement"></param>
public ReturnStatement Copy(IReturnStatement returnStatement)
{
var mutableCopy = this.shallowCopier.Copy(returnStatement);
if (mutableCopy.Expression != null)
mutableCopy.Expression = this.Copy(mutableCopy.Expression);
return mutableCopy;
}
public override void TraverseChildren(IReturnStatement returnStatement)
{
MethodEnter(returnStatement);
base.TraverseChildren(returnStatement);
MethodExit();
}
/// <summary>
/// Returns a shallow copy of the return statement.
/// </summary>
/// <param name="returnStatement"></param>
public ReturnStatement Copy(IReturnStatement returnStatement)
{
return new ReturnStatement(returnStatement);
}
/// <inheritdoc />
public override Expression VisitReturnStatement(IReturnStatement operation, LocalBinder argument)
{
return(Expression.Return(ReturnTarget));
}
public void Visit(IReturnStatement returnStatement)
{
this.result = this.copier.Copy(returnStatement);
}
