public static IEnumerable<IDeclaredType> GetResolvedTypeParams(IResolveResult resolution) {
var sub = resolution.Substitution;
var domainList = sub.Domain.ToList().OrderBy(x => x.Index);
var typeParams = domainList.Select(x => sub.Apply(x).GetScalarType());
return typeParams;
}
private string CalculateNextStatus(IResolveResult resolveResult, string currentStatus)
{
string nextStatus = null;
if (resolveResult.IsOnline)
{
if (resolveResult.Latency > _strategy.LatencyThreshold &&
currentStatus != ApiConstants.Permalinks.DegradedPerformance)
{
nextStatus = ApiConstants.Permalinks.DegradedPerformance;
_logger.LogInformation("Online with degraded performance.");
}
else if (currentStatus != ApiConstants.Permalinks.Operational)
{
nextStatus = ApiConstants.Permalinks.Operational;
_logger.LogInformation("Online.");
}
}
else if (currentStatus == ApiConstants.Permalinks.Operational)
{
nextStatus = ApiConstants.Permalinks.PartialOutage;
_logger.LogInformation("Offline. Declaring partial outage!");
}
else if (currentStatus == ApiConstants.Permalinks.PartialOutage)
{
nextStatus = ApiConstants.Permalinks.MajorOutage;
_logger.LogInformation("Still offline. Major outage!");
}
return(nextStatus);
}
public static IEnumerable <IDeclaredType> GetResolvedTypeParams(IResolveResult resolution)
{
var sub = resolution.Substitution;
var domainList = sub.Domain.ToList().OrderBy(x => x.Index);
var typeParams = domainList.Select(x => sub.Apply(x).GetScalarType());
return(typeParams);
}
private static DeclaredElementInstance TryResolveReference([CanBeNull] IReference reference)
{
IResolveResult resolveResult = reference?.Resolve().Result;
if (resolveResult?.DeclaredElement != null)
{
return(new DeclaredElementInstance(resolveResult.DeclaredElement, resolveResult.Substitution));
}
return(null);
}
public Refers RefersToDeclaredElement(IDeclaredElement declaredElement)
{
IResolveResult resolveResult = Resolve().Result;
if (Equals(resolveResult.DeclaredElement, declaredElement))
{
return(Refers.YES);
}
return(resolveResult.Candidates.Any(element => Equals(element, declaredElement)) ? Refers.MAYBE : Refers.NO);
}
// This will be called multiple times in the case of chained method calls.
public override void VisitInvocationExpression(IInvocationExpression invocationExpressionParam)
{
// TODO: Loop through here somehow and work up through the string calls like ToLower().ToUpper() et et.
//do
// {
IReferenceExpression expression = invocationExpressionParam.InvokedExpression as IReferenceExpression;
if (expression == null)
{
return;
}
// As I understand it this takes the abstract syntax element that is e.ToString() and resolves it such that
// we know it's the System.Enum.ToString() method call.
IResolveResult resolveResult = expression.Reference.Resolve();
IDeclaredElement e = resolveResult.DeclaredElement;
if (e == null)
{
return;
}
ITypeElement containingType = e.GetContainingType();
// work up through the string calls
//invocationExpressionParam = invocationExpressionParam.InvocationExpressionReference as IInvocationExpression;
//var allowed = new[] { "ToUpper", "ToLower", "ToString" };
//if (!new List<string>(allowed).Contains(e.ShortName))
// return;
// }
//while (containingType != null && containingType.CLRName == "System.String");
if (containingType == null)
{
return;
}
if (containingType.CLRName == "System.Enum" && e.ShortName == "ToString")
{
Found = true;
// Save the enum declaration so we can implement the fix.
this.FoundEnumReference = invocationExpressionParam.Reference;
this.EnumReferenceName = expression.QualifierExpression.GetText();
IExpressionType qe = expression.QualifierExpression.GetExpressionType();
this.EnumDeclaredName = ((IDeclaredType)qe).GetPresentableName(PsiLanguageType.GetByProjectFile(invocationExpressionParam.GetProjectFile()));
}
}
public async Task UpdateAsync(ResolveContext ctx, CancellationToken ct)
{
try
{
var currentStatus = await _staytus.GetStatusAsync(_service.Key);
// Check for maintenance period
if (currentStatus == ApiConstants.Permalinks.Maintenance)
{
_logger.LogWarning("Marked as under maintenance. Skipping for this interval.",
_service.Key);
// No-Op
return;
}
// Try to resolve N times until success.
IResolveResult resolveResult = default;
int i;
for (i = 0; i < _strategy.RetryAmount; i++)
{
resolveResult = await _resolver.ResolveStatusAsync(ctx);
if (resolveResult.IsOnline)
{
break;
}
// Give the service some time to get it together.
await Task.Delay(100, ct);
}
_logger.LogDebug("Attempted to resolve {0} time(s), service {1}", i + 1,
resolveResult?.IsOnline ?? false ? "Online" : "Offline");
var newStatus = CalculateNextStatus(resolveResult, currentStatus);
if (newStatus != null)
{
_logger.LogDebug("Updating status {1} -> {2}", _service.Key, currentStatus, newStatus);
await _staytus.UpdateStatusAsync(_service.Key, newStatus);
}
}
catch (Exception ex)
{
_logger.LogWarning("[0] An exception was thrown while attempting to update:\r\n {1}",
_service.Key, ex);
}
}
public static void AppendCandidates([NotNull] this CSharpColorizer colorizer, [CanBeNull] IReference reference)
{
if (reference == null)
{
return;
}
IResolveResult resolveResult = reference.Resolve().Result;
IList <IDeclaredElement> candidates = resolveResult.Candidates;
IList <ISubstitution> substitutions = resolveResult.CandidateSubstitutions;
for (int i = 0; i < candidates.Count; ++i)
{
colorizer.AppendPlainText(Environment.NewLine);
colorizer.AppendPlainText(" ");
colorizer.AppendDeclaredElement(candidates[i].EliminateDelegateInvokeMethod(), substitutions[i], PresenterOptions.FullWithoutParameterNames, reference.GetTreeNode());
}
}
private static DeclaredElementInstance GetBestReference([NotNull] IEnumerable <IReference> references)
{
foreach (IReference reference in references.OrderBy(r => r.GetTreeNode().PathToRoot().Count()))
{
IResolveResult resolveResult = reference.Resolve().Result;
if (reference.CheckResolveResult() == ResolveErrorType.DYNAMIC)
{
return(null);
}
IDeclaredElement foundElement = resolveResult.DeclaredElement;
if (foundElement != null)
{
return(new DeclaredElementInstance(foundElement, resolveResult.Substitution));
}
}
return(null);
}
public override IEnumerable <IComponentRegistration> GetComponentRegistrations(ITreeNode registrationRootElement)
{
IStructuralMatchResult match = Match(registrationRootElement);
if (match.Matched)
{
var expression = match.GetMatchedElement <IObjectCreationExpression>("expression");
if (expression != null && expression.TypeReference != null)
{
IResolveResult resolveResult = expression.TypeReference.Resolve().Result;
var @class = resolveResult.DeclaredElement as IClass;
if (@class != null)
{
yield return(new ComponentRegistration(registrationRootElement, @class, @class));
}
}
}
}
public override Expression Build()
{
IResolveResult resolve = expression.Reference.Resolve().Result;
ExtensionInstance <IDeclaredElement> element = resolve.ElementAsExtension();
var property = element.Element as IProperty;
if (property != null)
{
if (property.XMLDocId == "P:System.Array.Length")
{
return(Expression.ArrayLength(context));
}
}
MemberInfo memberInfo = GetReferencedMember(element.Element.ShortName, context.Type);
return(Expression.MakeMemberAccess(context, memberInfo));
}
private static DeclaredElementInfo GetBestReference([NotNull] IEnumerable <IReference> references, [NotNull] IFile file)
{
foreach (IReference reference in references.OrderBy(r => r.GetTreeNode().PathToRoot().Count()))
{
IResolveResult resolveResult = reference.Resolve().Result;
if (reference.CheckResolveResult() == ResolveErrorType.DYNAMIC)
{
return(null);
}
IDeclaredElement foundElement = resolveResult.DeclaredElement;
if (foundElement != null)
{
var referenceRange = reference.GetDocumentRange().TextRange;
return(new DeclaredElementInfo(foundElement, resolveResult.Substitution, file, referenceRange, reference));
}
}
return(null);
}
public IModule GetTargetModule <T>(T element)
{
var referenceExpression = element as IReferenceExpression;
if (referenceExpression == null)
{
return(null);
}
if (referenceExpression.Reference.GetName() == "ThisAssembly")
{
IResolveResult resolveResult = referenceExpression.Reference.Resolve().Result;
IDeclaredElement declaredElement = resolveResult.DeclaredElement;
if (declaredElement == null)
{
return(null);
}
var property = declaredElement as IProperty;
if (property == null)
{
return(null);
}
ITypeElement propertyType = property.GetContainingType();
if (propertyType == null)
{
return(null);
}
if (!propertyType.GetClrName().Equals(autofacModuleName))
{
return(null);
}
return(referenceExpression.GetPsiModule().ContainingProjectModule);
}
return(null);
}
public IModule GetTargetModule <T>(T element)
{
var referenceExpression = element as IReferenceExpression;
if (referenceExpression == null)
{
return(null);
}
if (referenceExpression.Reference.GetName() == methodName)
{
IResolveResult resolveResult = referenceExpression.Reference.Resolve().Result;
IDeclaredElement declaredElement = resolveResult.DeclaredElement;
if (declaredElement == null)
{
return(null);
}
var clrDeclaredElement = declaredElement as IClrDeclaredElement;
if (clrDeclaredElement == null)
{
return(null);
}
ITypeElement clrType = clrDeclaredElement.GetContainingType();
if (clrType == null)
{
return(null);
}
if (!clrType.GetClrName().Equals(clrTypeName))
{
return(null);
}
return(referenceExpression.GetPsiModule().ContainingProjectModule);
}
return(null);
}
public static void AppendCandidates([NotNull] this CSharpColorizer colorizer, [CanBeNull] IReference reference)
{
if (reference == null)
{
return;
}
IResolveResult resolveResult = reference.Resolve().Result;
var liftedResolveResult = resolveResult as LiftedResolveResult;
// ReSharper disable once CoVariantArrayConversion
IList <IDeclaredElement> candidates = liftedResolveResult != null ? liftedResolveResult.LiftedCandidates : resolveResult.Candidates;
IList <ISubstitution> substitutions = resolveResult.CandidateSubstitutions;
for (int i = 0; i < candidates.Count; ++i)
{
colorizer.AppendPlainText(Environment.NewLine);
colorizer.AppendPlainText(" ");
colorizer.AppendDeclaredElement(candidates[i].EliminateDelegateInvokeMethod(), substitutions[i], PresenterOptions.FullWithoutParameterNames);
}
}
public async Task RouteAsync(RouteContext context)
{
// Abort and proceed to other routes in the route table if path contains api or ui
string[] segments = context.HttpContext.Request.Path.Value.Split(new[] { '/' });
if (segments.Any(segment => segment.Equals("api", StringComparison.OrdinalIgnoreCase) ||
segment.Equals("brics", StringComparison.OrdinalIgnoreCase)))
{
return;
}
var requestCulture = DetectRequestCulture(context.HttpContext);
IResolveResult result = await _routeResolver.Resolve(context, requestCulture);
if (result != null)
{
context.RouteData.Values[ControllerKey] = result.Controller;
context.RouteData.Values[ActionKey] = result.Action;
context.HttpContext.Items[CurrentNodeKey] = result.TrieNode;
}
await _next.RouteAsync(context);
}
/// <summary>
/// Called at the end of resolve.
/// </summary>
public virtual void PostResolve(IResolveResult result)
{
}
private IEnumerable <IComponentRegistration> GetRegistrationsFromExpression(ITreeNode registrationRootElement, ICSharpExpression expression)
{
var castExpression = expression as ICastExpression;
if (castExpression != null)
{
var predefinedTypeUsage = castExpression.TargetType as IUserTypeUsage;
if (predefinedTypeUsage != null && predefinedTypeUsage.ScalarTypeName != null)
{
IResolveResult resolveResult = predefinedTypeUsage.ScalarTypeName.Reference.Resolve().Result;
var typeElement = resolveResult.DeclaredElement as ITypeElement;
if (typeElement != null)
{
yield return(new ServiceRegistration(registrationRootElement, typeElement));
}
}
}
var asExpression = expression as IAsExpression;
if (asExpression != null)
{
var typeUsage = asExpression.TypeOperand as IUserTypeUsage;
if (typeUsage != null && typeUsage.ScalarTypeName != null)
{
IResolveResult resolveResult = typeUsage.ScalarTypeName.Reference.Resolve().Result;
var typeElement = resolveResult.DeclaredElement as ITypeElement;
if (typeElement != null)
{
yield return(new ServiceRegistration(registrationRootElement, typeElement));
}
}
}
var objectCreationExpression = expression as IObjectCreationExpression;
if (objectCreationExpression != null && objectCreationExpression.TypeReference != null)
{
IResolveResult resolveResult = objectCreationExpression.TypeReference.Resolve().Result;
var @class = resolveResult.DeclaredElement as IClass;
if (@class != null)
{
yield return(new ComponentRegistration(registrationRootElement, @class, @class));
}
}
var invocationExpression = expression as IInvocationExpression;
if (invocationExpression != null)
{
if (invocationExpression.Reference != null)
{
var result = invocationExpression.Reference.Resolve().Result.DeclaredElement as IParametersOwner;
if (result != null)
{
var type = result.ReturnType as IDeclaredType;
if (type != null)
{
var @class = type.GetTypeElement();
if (@class != null)
{
yield return(new ComponentRegistration(registrationRootElement, @class, @class));
}
}
}
}
}
}
/// <summary>
/// Unused.
/// </summary>
public void PostResolve(IResolveResult result)
{
}
