static public MethodExpressionAnalysis FromSemanticModel(MethodDeclarationSyntax methodSyntax, SemanticModel semanticModel)
{
var expression = SyntaxOperations.GetBodyOfMethod(methodSyntax).B.Common;
var dataFlow = semanticModel.AnalyzeDataFlow(expression);
return(new MethodExpressionAnalysis(methodSyntax, expression, semanticModel, dataFlow));
}
static public (IXor2ComputationNodeReference, AlreadyProcessedSyntaxNodes) FromReturnStatement(ReturnStatementSyntax returnSyntax, MethodBlockAnalysis methodAnalysis, TextSpan span, AlreadyProcessedSyntaxNodes processedNodesOrNull = null)
{
Throw.IfNot(methodAnalysis.DataFlowAnalysis.Succeeded);
var processedNodes = (processedNodesOrNull ?? new AlreadyProcessedSyntaxNodes());
if (!span.Contains(returnSyntax.Span))
{
return(_CreatePair(Xor2ComputationNodeReference.OutOfScope(returnSyntax), processedNodes));
}
var rhsSyntax = SyntaxOperations.GetRightHandSideExpression(returnSyntax);
var previous = _DispatchXor7ExpressionSyntax(rhsSyntax, methodAnalysis, processedNodes ?? new AlreadyProcessedSyntaxNodes(), span);
var node = ComputationGraphNode.FromReturnStatement(returnSyntax, previous.Item1);
if (!previous.Item1.IsA)
{
return(_CreatePair(node, previous.Item2));
}
return(_CreatePair(node, previous.Item2));
}
static public MethodBlockAnalysis FromSemanticModel(MethodDeclarationSyntax methodSyntax, SemanticModel semanticModel)
{
var block = SyntaxOperations.GetBodyOfMethod(methodSyntax).A;
var controlFlow = semanticModel.AnalyzeControlFlow(block);
var dataFlow = semanticModel.AnalyzeDataFlow(block);
return(new MethodBlockAnalysis(methodSyntax, block, semanticModel, controlFlow, dataFlow));
}
static public Maybe <FuncResult <IXor4IdentifierOriginSyntax, SimpleControlFlowAnalysisError> > GetIdentifierDeclarationSyntax(IdentifierNameSyntax syntax, MethodBlockAnalysis methodAnalysis)
{
Maybe <FuncResult <IXor4IdentifierOriginSyntax, SimpleControlFlowAnalysisError> > __Ok(IXor4IdentifierOriginSyntax ok) => new FuncResult <IXor4IdentifierOriginSyntax, SimpleControlFlowAnalysisError>(ok);
Maybe <FuncResult <IXor4IdentifierOriginSyntax, SimpleControlFlowAnalysisError> > __Error(SimpleControlFlowAnalysisError error) => new FuncResult <IXor4IdentifierOriginSyntax, SimpleControlFlowAnalysisError>(error);
var loopLikeSyntax = syntax.Ancestors().FirstOrDefault(x => SyntaxOperations.IsLoopLike(x));
if (loopLikeSyntax != null)
{
return(__Error(SimpleControlFlowAnalysisError.NotALinearControlFlow(loopLikeSyntax)));
}
else
{
var symbolInfo = methodAnalysis.SemanticModel.GetSymbolInfo(syntax);
switch (symbolInfo.Symbol.Kind)
{
case SymbolKind.NamedType:
case SymbolKind.Namespace:
{
return(Maybe.NoValue);
}
case SymbolKind.Local:
{
var declaratorSyntax = (VariableDeclaratorSyntax)symbolInfo.Symbol.DeclaringSyntaxReferences.Single().GetSyntax();
var delarationSyntax = declaratorSyntax.Ancestors().OfType <LocalDeclarationStatementSyntax>().First();
return(__Ok(new Xor4IdentifierOriginSyntax(delarationSyntax)));
}
case SymbolKind.Field:
{
var declaringSyntax = (FieldDeclarationSyntax)symbolInfo.Symbol.DeclaringSyntaxReferences.Single().GetSyntax();
return(__Ok(new Xor4IdentifierOriginSyntax(declaringSyntax)));
}
case SymbolKind.Property:
{
var declaringSyntax = (PropertyDeclarationSyntax)symbolInfo.Symbol.DeclaringSyntaxReferences.Single().GetSyntax();
return(__Ok(new Xor4IdentifierOriginSyntax(declaringSyntax)));
}
case SymbolKind.Parameter:
{
var declaringSyntax = (ParameterSyntax)symbolInfo.Symbol.DeclaringSyntaxReferences.Single().GetSyntax();
return(__Ok(new Xor4IdentifierOriginSyntax(declaringSyntax)));
}
default:
throw NotPreparedForThatCase.UnexpectedEnumException(symbolInfo.Symbol.Kind);
}
}
}
static (ConstructorSyntaxLink, bool IsCompleted) _StartingFromRec(ConstructorDeclarationSyntax ctorDeclarationSyntax, ClassDeclarationSyntax owingType, SemanticModel semanticModel)
{
var syntaxTree = ctorDeclarationSyntax.SyntaxTree;
var nextCtorPath = (ConstructorInitializerSyntax)ctorDeclarationSyntax
.DescendantNodes()
.Where(x => x.Kind() == SyntaxKind.BaseConstructorInitializer || x.Kind() == SyntaxKind.ThisConstructorInitializer)
.SingleOrDefault();
if (nextCtorPath == null)
{
return(_CreateFinalLink(owingType, ctorDeclarationSyntax), IsCompleted : true);
}
switch (nextCtorPath.Kind())
{
case SyntaxKind.ThisConstructorInitializer:
{
var nextCtor = _GetConstructor(owingType, nextCtorPath, semanticModel);
if (!nextCtor.Exists)
{
var incompleteLink = _CreateIncompleteIntermediateLink(owingClass: owingType, thisCtorDeclarationSyntax: ctorDeclarationSyntax, pathToNextCtor: nextCtorPath);
return(incompleteLink, IsCompleted : false);
}
var(nextLink, isComplete) = _StartingFromRec(nextCtor.Value, owingType, semanticModel: semanticModel);
var link = _CreateIntermediateLink(nextLink, owingClass: owingType, thisCtorDeclarationSyntax: ctorDeclarationSyntax, pathToNextCtor: nextCtorPath);
return(link, isComplete);
}
case SyntaxKind.BaseConstructorInitializer:
{
var baseTypeSyntax = SyntaxOperations.GetBaseTypeOf(owingType, syntaxTree, semanticModel).Value;
var nextCtor = _GetConstructor(baseTypeSyntax, nextCtorPath, semanticModel);
if (!nextCtor.Exists)
{
var incompleteLink = _CreateIncompleteIntermediateLink(owingClass: owingType, thisCtorDeclarationSyntax: ctorDeclarationSyntax, pathToNextCtor: nextCtorPath);
return(incompleteLink, IsCompleted : false);
}
var(nextLink, isCompleted) = _StartingFromRec(nextCtor.Value, owingType: baseTypeSyntax, semanticModel: semanticModel);
var link = _CreateIntermediateLink(nextLink, owingClass: owingType, thisCtorDeclarationSyntax: ctorDeclarationSyntax, pathToNextCtor: nextCtorPath);
return(link, isCompleted);
}
default:
throw NotPreparedForThatCase.CannotHappenException;
}
}
