/// <summary>Creates a variable declaration for catch clause.</summary> /// <param name="exceptionType">The type of a created variable.</param> /// <param name="context">The context. </param> public ICatchVariableDeclaration CreateCatchVariableDeclarationNode(IDeclaredType exceptionType, ITreeNode context) { var tryStatement = _factory.CreateStatement("try {} catch(Exception e) {}") as ITryStatement; if (tryStatement == null) { return(null); } var catchClause = tryStatement.Catches[0] as ISpecificCatchClause; if (catchClause == null) { return(null); } var exceptionDeclaration = catchClause.ExceptionDeclaration; if (exceptionDeclaration == null) { return(null); } if (exceptionType != null) { var declaredTypeUsageNode = _factory.CreateTypeUsage(exceptionType, context); catchClause.SetExceptionTypeUsage(declaredTypeUsageNode); } return(exceptionDeclaration); }
private static string GetModuleFullName([NotNull] IType type) { IDeclaredType scalarType = type.GetScalarType(); if (scalarType != null) { AssemblyNameInfo assembly = scalarType.Assembly; if (assembly != null) { return(assembly.FullName); } } var assemblyPsiModule = type.Module as IAssemblyPsiModule; if (assemblyPsiModule != null) { string name = assemblyPsiModule.Assembly.AssemblyName.FullName; if (name != null) { return(name); } } return(type.Module.DisplayName); }
/// <summary>Creates a try statement for the given exception type and variable name. </summary> /// <param name="exceptionType">The exception type. </param> /// <param name="exceptionVariableName">The exception variable name. </param> /// <param name="context">The context. </param> /// <returns>The try statement. </returns> public ITryStatement CreateTryStatement(IDeclaredType exceptionType, string exceptionVariableName, ITreeNode context) { var tryStatement = _factory.CreateStatement("try {} catch($0 $1) {}", exceptionType.GetClrName().ShortName, exceptionVariableName) as ITryStatement; if (tryStatement == null) { return(null); } var catchClause = tryStatement.Catches[0] as ISpecificCatchClause; if (catchClause == null) { return(tryStatement); } var exceptionDeclaration = catchClause.ExceptionDeclaration; if (exceptionDeclaration == null) { return(tryStatement); } #if R8 var declaredTypeUsageNode = _factory.CreateDeclaredTypeUsageNode(exceptionType); #else var declaredTypeUsageNode = _factory.CreateDeclaredTypeUsageNode(exceptionType, context); #endif exceptionDeclaration.SetDeclaredTypeUsage(declaredTypeUsageNode); return(tryStatement); }
public static bool IsAssignableFrom(this Type type, IDeclaredType c) { if (c == null) return false; return type.FullName == c.GetClrName().FullName || c.GetAllSuperTypes().Any(superType => type.FullName == superType.GetClrName().FullName); }
/// <summary>Creates a try statement for the given exception type and variable name. </summary> /// <param name="exceptionType">The exception type. </param> /// <param name="exceptionVariableName">The exception variable name. </param> /// <param name="context">The context. </param> /// <returns>The try statement. </returns> public ITryStatement CreateTryStatement(IDeclaredType exceptionType, string exceptionVariableName, ITreeNode context) { var tryStatement = _factory.CreateStatement("try {} catch($0 $1) {$2 // TODO: Handle the $0$2}", exceptionType.GetClrName().FullName, exceptionVariableName, Environment.NewLine) as ITryStatement; if (tryStatement == null) { return(null); } var catchClause = tryStatement.Catches[0] as ISpecificCatchClause; if (catchClause == null) { return(tryStatement); } var exceptionDeclaration = catchClause.ExceptionDeclaration; if (exceptionDeclaration == null) { return(tryStatement); } var declaredTypeUsageNode = _factory.CreateTypeUsage(exceptionType, context); catchClause.SetExceptionTypeUsage(declaredTypeUsageNode); return(tryStatement); }
public override void VisitDeclaredType(IDeclaredType declaredType) { if (!myTypes.Add(declaredType)) { return; } var typeElement = declaredType.GetTypeElement(); if (typeElement == null) { return; } var substitution = declaredType.GetSubstitution(); var typeParameters = typeElement.TypeParameters; if (typeParameters.Count == 0) { return; } foreach (var typeParameter in typeParameters) { substitution[typeParameter].Accept(this); } }
/// <summary>Creates a specific catch clause with given <paramref name="exceptionType"/> and <paramref name="catchBody"/>.</summary> /// <param name="exceptionType">Type of the exception to catch.</param> /// <param name="catchBody">Body of the created catch.</param> /// <param name="variableName">A name for catch variable.</param> public ISpecificCatchClause CreateSpecificCatchClause(IDeclaredType exceptionType, IBlock catchBody, string variableName) { var tryStatement = _factory.CreateStatement("try {} catch(Exception $0) {}", variableName) as ITryStatement; if (tryStatement == null) return null; var catchClause = tryStatement.Catches[0] as ISpecificCatchClause; if (catchClause == null) return null; if (catchBody == null) { catchBody = _factory.CreateBlock("{$1 // TODO: Handle the $0 $1}", exceptionType.GetClrName().ShortName, Environment.NewLine); } if (exceptionType != null) { var exceptionDeclaration = catchClause.ExceptionDeclaration; if (exceptionDeclaration == null) return null; #if R8 var declaredTypeUsageNode = _factory.CreateDeclaredTypeUsageNode(exceptionType); #else var declaredTypeUsageNode = _factory.CreateDeclaredTypeUsageNode(exceptionType, catchBody); #endif exceptionDeclaration.SetDeclaredTypeUsage(declaredTypeUsageNode); } catchClause.SetBody(catchBody); return catchClause; }
private static bool IsTaskType(IDeclaredType type) { string typeName = type.GetClrName().FullName; return(string.Equals(typeName, TaskTypeName, StringComparison.Ordinal) || string.Equals(typeName, TaskOfTTypeName, StringComparison.Ordinal)); }
private bool IsNinjectBindCall(ITreeNode element) { var invocationExpression = element as IInvocationExpression; if (invocationExpression == null) { return(false); } var resolve = invocationExpression.InvocationExpressionReference.Resolve().Result; var method = resolve.DeclaredElement as IMethod; if (method == null) { return(false); } ITypeElement containingType = method.GetContainingType(); if (containingType == null) { return(false); } if (bindingRootType == null) { bindingRootType = TypeFactory.CreateTypeByCLRName("Ninject.Syntax.IBindingRoot", element.GetPsiModule()); } return(containingType.IsDescendantOf(bindingRootType.GetTypeElement())); }
public void Generate(CSharpGeneratorContext context, IList <GeneratorDeclaredElement <ITypeOwner> > elements, CSharpElementFactory factory) { IMethodDeclaration methodDeclaration = null; ITypeElement declaredElement = context.ClassDeclaration.DeclaredElement; if (declaredElement != null) { IDeclaredType byteType = TypeFactory.CreateTypeByCLRName(PredefinedType.BYTE_FQN, context.PsiModule, context.Anchor.GetResolveContext()); _byteArrayType = TypeFactory.CreateArrayType(byteType, 1); _typeConversionRule = new CSharpTypeConversionRule(context.PsiModule); IOverridableMember member = declaredElement.Methods.FirstOrDefault(ValidateMethod); if (member != null) { methodDeclaration = (IMethodDeclaration)member.GetDeclarations().FirstOrDefault(); Generate(context, methodDeclaration, elements, factory); return; } } string method = String.Format("public Int32 {0}(Byte[] bytes, Int32 startIndex)", MethodName); methodDeclaration = (IMethodDeclaration)factory.CreateTypeMemberDeclaration(method); Generate(context, methodDeclaration, elements, factory); context.PutMemberDeclaration(methodDeclaration, null, newDeclaration => new GeneratorDeclarationElement(newDeclaration)); }
public static bool IsContainerCall(this ITreeNode node, string containerClrTypeName) { var invocationExpression = node as IInvocationExpression; if (invocationExpression == null) { return(false); } var resolve = invocationExpression.InvocationExpressionReference.Resolve().Result; var method = resolve.DeclaredElement as IMethod; if (method == null) { return(false); } ITypeElement containingType = method.GetContainingType(); if (containingType == null) { return(false); } IDeclaredType containerClrType = CreateTypeByClrName(node, containerClrTypeName); return(containingType.IsDescendantOf(containerClrType.GetTypeElement())); }
private bool ownsTypeMatch(IDeclaration declaration) { if (string.IsNullOrEmpty(_isOfType)) { return(true); } if (_isOfTypeType == null) { return(false); } if (declaration is ITypeOwner) { IDeclaredType declaredType = ((ITypeOwner)declaration).Type as IDeclaredType; if (declaredType == null) { return(false); } ITypeElement typeElement = declaredType.GetTypeElement(); if (typeElement == null) { return(false); } return(typeElement.IsDescendantOf(_isOfTypeType)); } else { return(false); } }
public static void Initialize(CSharpGeneratorContext context) { IDeclaredType byteType = TypeFactory.CreateTypeByCLRName(PredefinedType.BYTE_FQN, context.PsiModule, context.Anchor.GetResolveContext()); _byteArrayType = TypeFactory.CreateArrayType(byteType, 1); _conversionRule = new CSharpTypeConversionRule(context.PsiModule); }
private ICSharpStatement CreateRequiresStatement(bool isGeneric) { Contract.Ensures(Contract.Result <ICSharpStatement>() != null); ITypeElement contractType = CreateDeclaredType(typeof(Contract)); ITypeElement systemEnumType = CreateDeclaredType(typeof(System.Enum)); ITypeElement customEnumType = CreateDeclaredType(_availability.ParameterUnderlyingType); ICSharpStatement statement = null; if (isGeneric) { string format = "$0.Requires<$1>($2.IsDefined(typeof($3), $4));"; IDeclaredType argumentException = GetPredefinedType().ArgumentException; statement = _factory.CreateStatement(format, contractType, argumentException, systemEnumType, customEnumType, _availability.ParameterName); } else { string format = "$0.Requires($1.IsDefined(typeof($2), $3));"; statement = _factory.CreateStatement(format, contractType, systemEnumType, customEnumType, _availability.ParameterName); } return(statement); }
static bool IsTestMethodOfOldMsTest([CanBeNull] IMethodDeclaration methodDeclaration) { if (methodDeclaration == null || !methodDeclaration.IsDeclaredInOldMsTestProject()) { return(false); } var testMethodAttributeTypes = null as IDeclaredType[]; return(methodDeclaration.Attributes.Any( attribute => { if (attribute == null) { return false; } if (testMethodAttributeTypes == null) { testMethodAttributeTypes = new IDeclaredType[testMethodAttributes.Length]; for (var i = 0; i < testMethodAttributes.Length; i++) { testMethodAttributeTypes[i] = TypeFactory.CreateTypeByCLRName( testMethodAttributes[i], NullableAnnotation.Unknown, methodDeclaration.GetPsiModule()); } } var attributeType = attribute.GetAttributeInstance().GetAttributeType(); return testMethodAttributeTypes.Any( type => attributeType.Equals(type, TypeEqualityComparer.Default) || attributeType.IsSubtypeOf(type)); })); }
/// <summary> /// Translates a general-case declared type. /// </summary> /// <param name="declaredType">The <see cref="IDeclaredType"/> to translate.</param> public virtual void TranslateType(IDeclaredType declaredType) { if (declaredType is IClassType) { this.TranslateType((IClassType)declaredType); } else if (declaredType is IEnumeratorType) { this.TranslateType((IEnumeratorType)declaredType); } else if (declaredType is IDelegateType) { this.TranslateType((IDelegateType)declaredType); } else if (declaredType is IInterfaceType) { this.TranslateType((IInterfaceType)declaredType); } else if (declaredType is IStructType) { this.TranslateType((IStructType)declaredType); } else { throw new NotSupportedException(string.Format("Type {0} not supported", declaredType.GetType().Name)); } }
public static string CatchVariableName(ITreeNode treeNode, IDeclaredType exceptionType) { var namingPolicyManager = new NamingPolicyManager(LanguageManager.Instance, treeNode.GetSolution()); var nameParser = new NameParser(treeNode.GetSolution(), namingPolicyManager, new HostCulture()); var nameSuggestionManager = new NameSuggestionManager(treeNode.GetSolution(), nameParser, namingPolicyManager); var policy = namingPolicyManager.GetPolicy(NamedElementKinds.Locals, treeNode.Language, treeNode.GetSourceFile()); var namesCollection = nameSuggestionManager.CreateEmptyCollection( PluralityKinds.Single, treeNode.Language, true, treeNode.GetSourceFile()); var entryOptions = new EntryOptions { PluralityKind = PluralityKinds.Single, PredefinedPrefixPolicy = PredefinedPrefixPolicy.Preserve, Emphasis = Emphasis.Good, SubrootPolicy = SubrootPolicy.Decompose }; namesCollection.Add(exceptionType, entryOptions); namesCollection.Prepare(policy.NamingRule, ScopeKind.Common, new SuggestionOptions()); try { return(namesCollection.GetRoots().FirstOrDefault()?.GetFinalPresentation() ?? String.Empty); } catch (ArgumentNullException) { return(String.Empty); } }
private static IList <string> ProcessArgumentsExpression(IArgumentsOwner argumentsOwner, MvcKind kind) { #if SDK80 IDeclaredType stringType = TypeFactory.CreateTypeByCLRName(PredefinedType.STRING_FQN, argumentsOwner.GetPsiModule(), argumentsOwner.GetResolveContext()); #else IDeclaredType stringType = TypeFactory.CreateTypeByCLRName(PredefinedType.STRING_FQN, argumentsOwner.GetPsiModule()); #endif var enumerabe1 = from expression in RetrieveArgumentExpressions(argumentsOwner, kind) let finder = new RecursiveElementCollector <IExpression>( literalExpression => { if (!literalExpression.GetExpressionType().IsImplicitlyConvertibleTo( stringType, IntentionLanguageSpecific.GetTypeConversion(literalExpression))) { return(false); } string initializerName; IInvocationInfo invocationInfo; GetMvcLiteral(literalExpression, out invocationInfo, out initializerName); return((invocationInfo == argumentsOwner) && expression.Second.Any(_ => StringComparer.OrdinalIgnoreCase.Equals(_.B, initializerName))); }) select new { finder, expression }; return((from x in enumerabe1 from literal in x.finder.ProcessElement(x.expression.First).GetResults() select literal.ConstantValue.Value as string).ToList()); }
/// <summary>Creates a variable declaration for catch clause.</summary> /// <param name="exceptionType">The type of a created variable.</param> /// <param name="context">The context. </param> public ICatchVariableDeclaration CreateCatchVariableDeclarationNode(IDeclaredType exceptionType, ITreeNode context) { var tryStatement = _factory.CreateStatement("try {} catch(Exception e) {}") as ITryStatement; if (tryStatement == null) return null; var catchClause = tryStatement.Catches[0] as ISpecificCatchClause; if (catchClause == null) return null; var exceptionDeclaration = catchClause.ExceptionDeclaration; if (exceptionDeclaration == null) return null; if (exceptionType != null) { #if R8 var declaredTypeUsageNode = _factory.CreateDeclaredTypeUsageNode(exceptionType); #else var declaredTypeUsageNode = _factory.CreateDeclaredTypeUsageNode(exceptionType, context); #endif exceptionDeclaration.SetDeclaredTypeUsage(declaredTypeUsageNode); } return exceptionDeclaration; }
private IDeclaredType GetExceptionType() { if (_exceptionTypeLoaded) { return(_exceptionType); } try { #if R10 _exceptionType = TypeFactory.CreateTypeByCLRName(ExceptionType, ServiceLocator.StageProcess.PsiModule); #else _exceptionType = TypeFactory.CreateTypeByCLRName(ExceptionType, ServiceLocator.StageProcess.PsiModule, ServiceLocator.StageProcess.PsiModule.GetContextFromModule()); #endif } catch (Exception ex) { Logger.LogException(string.Format("[Exceptional] Error loading excluded method exception '{0}'", ExceptionType), ex); } finally { _exceptionTypeLoaded = true; } return(_exceptionType); }
private static bool IsInstantiableExceptionType([NotNull] IDeclaredType declaredType, [NotNull] ICSharpExpression context) { var predefinedType = context.GetPredefinedType(); var conversionRule = context.GetTypeConversionRule(); return(conversionRule.IsImplicitlyConvertibleTo(declaredType, predefinedType.Exception) && TypeUtils.CanInstantiateType(declaredType, context) != CanInstantiate.No); }
/// <summary>Adds a catch clause to the try statement. </summary> /// <param name="exceptionType">The exception type in the added catch clause. </param> public void AddCatchClause(IDeclaredType exceptionType) { var codeElementFactory = new CodeElementFactory(GetElementFactory()); var variableName = NameFactory.CatchVariableName(Node, exceptionType); var catchClauseNode = codeElementFactory.CreateSpecificCatchClause(exceptionType, null, variableName); Node.AddCatchClause(catchClauseNode); }
IMembers IMembers.GetPartialClone(IDeclaredType parent) { if (!(parent is TParent)) { throw new ArgumentException("must be of type TParent", "parent"); } return((IMembers)this.OnGetPartialClone((TParent)parent)); }
public ContractResultPredicateArgument(IDeclaredType resultTypeName, IReferenceExpression contractResultReference) { Contract.Requires(resultTypeName != null); Contract.Requires(contractResultReference != null); _resultTypeName = resultTypeName; _contractResultReference = contractResultReference; }
/// <summary>Checks whether the block catches the given exception. </summary> /// <param name="exception">The exception. </param> /// <returns><c>true</c> if the exception is caught in the block; otherwise, <c>false</c>. </returns> public override bool CatchesException(IDeclaredType exception) { if (CatchClauses.Any(catchClauseModel => catchClauseModel.Catches(exception))) { return(true); } return(ParentBlock.CatchesException(exception)); }
public void HandleGetSize(TypeHandlingContext context) { IDeclaredType valueType = context.Type.GetScalarType(); if (valueType == null) { throw new NotSupportedException(); } ITypeHandler valueHandler = TypeHandlers.All.SingleOrDefault(h => h.CanHandle(context.WithType(valueType))); if (valueHandler == null) { throw new NotSupportedException(); } var exists = context.Variables.Declare(VariableKeys.NotNull); context.Builder.AppendFormat("var {0} = {1} != null;", exists, context.TypeOwnerName); TypeHandlers.Boolean.HandleGetSize(new TypeHandlingContext(context) { TypeOwnerName = exists }); context.Builder.AppendFormat("if({0})", exists).Append("{"); TypeHandlers.Int32.HandleGetSize(new TypeHandlingContext(context) { TypeOwnerName = String.Format("{0}.Length", context.TypeOwnerName) }); context.Builder.AppendFormat("if({0}.Length > 0)", context.TypeOwnerName); context.Builder.Append("{"); if (valueHandler.BinarySizePersistent) { var size = context.Variables.Declare(VariableKeys.ValueSize); context.Builder.AppendFormat("var {0} = 0;", size); valueHandler.HandleGetSize(new TypeHandlingContext(context) { SizeVariableKey = VariableKeys.ValueSize }); context.Builder.AppendFormat("{0} += {1}*{2}.Length;", context.GetSizeVariableName(), size, context.TypeOwnerName); } else { var indexName = context.Variables.Declare(Index); context.Builder.AppendFormat("for(Int32 {0} = 0; {0} < {1}.Length; {0}++)", indexName, context.TypeOwnerName); context.Builder.Append("{"); valueHandler.HandleGetSize(new TypeHandlingContext(context) { TypeOwnerName = String.Format("{0}[{1}]", context.TypeOwnerName, indexName) }); context.Builder.Append("}"); } context.Builder.Append("}}"); }
private static bool AddEnumerationMembers([NotNull] CSharpCodeCompletionContext context, [NotNull] GroupedItemsCollector collector, [NotNull] IDeclaredType qualifierType, [NotNull] IReferenceExpression referenceExpression) { var enumerationType = (IEnum)qualifierType.GetTypeElement().NotNull(); var substitution = qualifierType.GetSubstitution(); var memberValues = new List <Pair <IField, string> >(); var isFlagsEnum = enumerationType.HasAttributeInstance(FlagsAttributeClrName, false); if (!isFlagsEnum) { foreach (var member in enumerationType.EnumMembers) { var formattable = member.ConstantValue.Value as IFormattable; var memberValue = (formattable != null) ? formattable.ToString("D", CultureInfo.InvariantCulture) : string.Empty; memberValues.Add(Pair.Of(member, memberValue)); } } else { foreach (var member in enumerationType.EnumMembers) { var convertible = member.ConstantValue.Value as IConvertible; var memberValue = (convertible != null) ? GetBinaryRepresentation(convertible) : string.Empty; memberValues.Add(Pair.Of(member, memberValue)); } } if (memberValues.Count == 0) { return(false); } // create pointer to . in reference expression var maxLength = memberValues.Max(x => x.Second.Length); var reparsedDotRange = referenceExpression.Delimiter.GetTreeTextRange(); var originalDotRange = context.UnterminatedContext.ToOriginalTreeRange(reparsedDotRange); var file = context.BasicContext.File; var dotMarker = file.GetDocumentRange(originalDotRange).CreateRangeMarker(); foreach (var member in memberValues) { var normalizedValue = member.Second.PadLeft(maxLength, '0'); var value = isFlagsEnum ? normalizedValue : member.Second; var instance = new DeclaredElementInstance <IField>(member.First, substitution); var textLookupItem = new EnumMemberLookupItem(dotMarker, instance, normalizedValue, value, isFlagsEnum); collector.AddSomewhere(textLookupItem); } return(true); }
protected override void Run(IClassDeclaration classDeclaration, ElementProblemAnalyzerData data, IHighlightingConsumer consumer) { if (!myIsEnabled.Value) { return; } var typeElement = classDeclaration.DeclaredElement; if (typeElement == null || !ZoneConstants.IsZoneClass(typeElement)) { return; } var mark = myMarks.GetMark(typeElement.GetContainingNamespace()); var classes = myMarks.EnumerateClasses(mark).ToList(); // find all base zones var baseZones = new HashSet <IClass>(); foreach (var cls in classes) { foreach (var baseZone in MarksService.EnumerableMarkClasses(cls, true)) { if (!baseZone.Equals(cls)) { baseZones.Add(baseZone); } } } foreach (var typeUsage in classDeclaration.SuperTypeUsageNodes.OfType <IUserDeclaredTypeUsage>()) { IDeclaredType superType = CSharpTypeFactory.CreateDeclaredType(typeUsage); var superTypeElement = superType.GetTypeElement(); if (superTypeElement != null) { if (ZoneConstants.IsIRequire(superTypeElement as IInterface)) { var substitution = superType.GetSubstitution(); foreach (var parameter in substitution.Domain) { var zoneType = substitution[parameter] as IDeclaredType; if (zoneType != null) { var zoneClass = zoneType.GetTypeElement() as IClass; if (zoneClass != null && baseZones.Contains(zoneClass)) { consumer.AddHighlighting(new RedundantDependencySpecificationError(typeUsage), classDeclaration.GetContainingNode <IFile>()); } } } } } } }
private bool IsAvailableInternal(IDataContext context, out IParameter systemTypeParameter, out IMethod method) { systemTypeParameter = null; method = null; var declaredElements = context.GetData(Psi.Services.DataConstants.DECLARED_ELEMENTS); if (declaredElements == null) { return(false); } method = declaredElements.OfType <IMethod>().FirstOrDefault(); if (method == null) { return(false); } if (method is ICompiledElement) { return(false); } IList <IDeclaration> declarations = method.GetDeclarations(); if (declarations.Count == 0) { return(false); } IList <IParameter> parameters = method.Parameters; if (parameters.Count == 0) { return(false); } IPsiModule module = method.Module; IDeclaredType systemType = TypeFactory.CreateTypeByCLRName("System.Type", module); foreach (IParameter parameter in parameters) { if (parameter.Type.Equals(systemType)) { systemTypeParameter = parameter; } } if (systemTypeParameter == null) { return(false); } return(true); }
public ChangeToAsyncTaskFix([NotNull] AvoidAsyncVoidHighlighting highlighting) { this.highlighting = highlighting; var psiModule = highlighting.MethodDeclaration.GetPsiModule(); var predefinedType = psiModule.GetPredefinedType(); taskType = predefinedType.Task; }
public ChangeToAsyncTaskFix([NotNull] AvoidAsyncVoidHighlighting highlighting) { this.highlighting = highlighting; var psiModule = highlighting.Declaration.GetPsiModule(); var predefinedType = psiModule.GetPredefinedType(); taskType = predefinedType.Task; }
public VarByTypeItem([NotNull] PrefixExpressionContext context, [NotNull] IDeclaredType referencedType) : base("var", context) { myReferencedType = referencedType; myLookupItemsOwner = context.PostfixContext.ExecutionContext.LookupItemsOwner; var canInstantiate = TypeUtils.CanInstantiateType(referencedType, context.Expression); myHasRequiredArguments = (canInstantiate & CanInstantiate.ConstructorWithParameters) != 0; }
static bool IsValidFieldOfType(this IDeclaredElement element, Type type) { IDeclaredType fieldType = element.GetValidatedFieldType(); if (fieldType == null) { return(false); } return(new CLRTypeName(fieldType.GetCLRName()) == new CLRTypeName(type.FullName)); }
protected virtual bool ResultIsAlreadyCheckedByContractEnsures( IEnumerable <ContractEnsures> ensureAssertions, IDeclaredType methodReturnType) { Contract.Requires(ensureAssertions != null); Contract.Requires(methodReturnType != null); return(ensureAssertions .Any(e => e.ChecksForNotNull( pa => pa.With(x => x as ContractResultPredicateArgument) .With(x => x.ResultTypeName.FullName) == methodReturnType.GetClrName().FullName))); }
public ThrownExceptionModel(IAnalyzeUnit analyzeUnit, IExceptionsOriginModel exceptionsOrigin, IDeclaredType exceptionType, string exceptionDescription, bool isEventInvocationException, string exceptionAccessor) : base(analyzeUnit) { ExceptionType = exceptionType; ExceptionDescription = exceptionDescription; ExceptionsOrigin = exceptionsOrigin; ExceptionAccessor = exceptionAccessor; IsEventInvocationException = isEventInvocationException; CheckAccessorOverride(exceptionsOrigin, exceptionType); }
private IEnumerable<IComponentRegistration> CreateRegistration(IInvocationExpression invocationExpression, IDeclaredType first, IDeclaredType last) { if (first == null || last == null) { yield break; } ITypeElement fromType = first.GetTypeElement(); ITypeElement toType = last.GetTypeElement(); if (fromType != null && toType != null) { yield return fromType.Equals(toType) ? new ComponentRegistration(invocationExpression, fromType) : new ComponentRegistration(invocationExpression, fromType, toType); } }
public override bool IsAvailable(IUserDataHolder cache) { using (ReadLockCookie.Create()) { if (Provider.SelectedElement != null) { _superType = TypeHelper.CreateTypeByCLRName(SuperTypeName, Provider.PsiModule, Provider.SelectedElement.GetResolveContext()); if (_superType.GetTypeElement() != null) { _classDeclaration = Provider.SelectedElement.Parent as IClassDeclaration; } } } // !_classDeclaration.IsStatic doesn't work, IsStatic is returns true return _classDeclaration != null && !_classDeclaration.IsStaticEx() && _classDeclaration.SuperTypes.IsEmpty(); }
// TODO: move close to the rest of errors and messages!! private static string ErrorForIncompatibleEnsuresAndReturnType(IType methodResult, IDeclaredType contractResult, ICSharpFunctionDeclaration method) { string kind = "method"; string name = method.DeclaredName; var property = method as IAccessorDeclaration; if (property != null) { kind = "property"; name = name.Replace("get_", ""); } return string.Format("Detected a call to Result with '{0}' in {1} '{2}', should be '{3}'", contractResult.GetPresentableName(CSharpLanguage.Instance), kind, name, methodResult.GetPresentableName(CSharpLanguage.Instance)); }
private IDeclaredType GetExceptionType() { if (_exceptionTypeLoaded) return _exceptionType; try { #if R10 _exceptionType = TypeFactory.CreateTypeByCLRName(ExceptionType, ServiceLocator.StageProcess.PsiModule); #else _exceptionType = TypeFactory.CreateTypeByCLRName(ExceptionType, ServiceLocator.StageProcess.PsiModule, ServiceLocator.StageProcess.PsiModule.GetContextFromModule()); #endif } catch (Exception ex) { Logger.LogException(string.Format("[Exceptional] Error loading excluded method exception '{0}'", ExceptionType), ex); } finally { _exceptionTypeLoaded = true; } return _exceptionType; }
public static string CatchVariableName(ITreeNode treeNode, IDeclaredType exceptionType) { var namingPolicyManager = new NamingPolicyManager(LanguageManager.Instance, treeNode.GetSolution()); var nameParser = new NameParser(treeNode.GetSolution(), namingPolicyManager); var nameSuggestionManager = new NameSuggestionManager(treeNode.GetSolution(), nameParser, namingPolicyManager); var policy = namingPolicyManager.GetPolicy(NamedElementKinds.Locals, treeNode.Language, treeNode.GetSourceFile()); var namesCollection = nameSuggestionManager.CreateEmptyCollection( PluralityKinds.Single, treeNode.Language, true, treeNode.GetSourceFile()); var entryOptions = new EntryOptions { PluralityKind = PluralityKinds.Single, PredefinedPrefixPolicy = PredefinedPrefixPolicy.Preserve, Emphasis = Emphasis.Good, SubrootPolicy = SubrootPolicy.Decompose }; namesCollection.Add(exceptionType, entryOptions); namesCollection.Prepare(policy.NamingRule, ScopeKind.Common, new SuggestionOptions()); return namesCollection.FirstName(); }
public bool IsException(IDeclaredType exceptionType) { if (ExceptionType == null) return false; if (exceptionType == null) return false; return ExceptionType.Equals(exceptionType); }
/// <summary>Creates a try statement for the given exception type and variable name. </summary> /// <param name="exceptionType">The exception type. </param> /// <param name="exceptionVariableName">The exception variable name. </param> /// <param name="context">The context. </param> /// <returns>The try statement. </returns> public ITryStatement CreateTryStatement(IDeclaredType exceptionType, string exceptionVariableName, ITreeNode context) { var tryStatement = _factory.CreateStatement("try {} catch($0 $1) {}", exceptionType.GetClrName().ShortName, exceptionVariableName) as ITryStatement; if (tryStatement == null) return null; var catchClause = tryStatement.Catches[0] as ISpecificCatchClause; if (catchClause == null) return tryStatement; var exceptionDeclaration = catchClause.ExceptionDeclaration; if (exceptionDeclaration == null) return tryStatement; #if R8 var declaredTypeUsageNode = _factory.CreateDeclaredTypeUsageNode(exceptionType); #else var declaredTypeUsageNode = _factory.CreateDeclaredTypeUsageNode(exceptionType, context); #endif exceptionDeclaration.SetDeclaredTypeUsage(declaredTypeUsageNode); return tryStatement; }
internal GenericExceptionNameBuilder(IDeclaredType exceptionType) { _exceptionType = exceptionType; }
private void CheckAccessorOverride(IExceptionsOriginModel exceptionsOrigin, IDeclaredType exceptionType) { var doc = GetXmlDocId(exceptionsOrigin.Node); if (doc != null) { var fullMethodName = Regex.Replace(doc.Substring(2), "(`[0-9]+)|(\\(.*?\\))", ""); // TODO: merge with other var overrides = ServiceLocator.Settings.GetExceptionAccessorOverrides(); var ov = overrides.SingleOrDefault( o => o.FullMethodName == fullMethodName && o.GetExceptionType().Equals(exceptionType)); if (ov != null) ExceptionAccessor = ov.ExceptionAccessor; } }
public OptionalExceptionConfiguration(IDeclaredType exceptionType, OptionalExceptionReplacementType replacementType) { ExceptionType = exceptionType; ReplacementType = replacementType; }
internal static bool IsAssignableFrom(this Type type, IDeclaredType c) { return type.FullName == c.GetClrName().FullName || c.GetAllSuperTypes().Any(superType => type.FullName == superType.GetClrName().FullName); }
public bool IsImplementingType(IDeclaredType type, Type implementedType) { return GetImplementedTypes(type).Any(x => x.GetClrName().FullName == implementedType.FullName); }
private bool IsNinjectBindCall(ITreeNode element) { var invocationExpression = element as IInvocationExpression; if (invocationExpression == null) { return false; } var resolve = invocationExpression.InvocationExpressionReference.Resolve().Result; var method = resolve.DeclaredElement as IMethod; if (method == null) { return false; } ITypeElement containingType = method.GetContainingType(); if (containingType == null) { return false; } if (bindingRootType == null) { bindingRootType = TypeFactory.CreateTypeByCLRName("Ninject.Syntax.IBindingRoot", element.GetPsiModule()); } return containingType.IsDescendantOf(bindingRootType.GetTypeElement()); }
protected override bool ResultIsAlreadyCheckedByContractEnsures(IEnumerable<ContractEnsures> ensureAssertions, IDeclaredType methodReturnType) { // Ensures for enums should be available for System.Enum and for System.Enum? // thats why we should extract underlying type out of the nullable type. var returnType = methodReturnType.IsNullable() ? methodReturnType.GetNullableUnderlyingType() : methodReturnType; return ensureAssertions .Any(e => e.ChecksForNotNull( pa => pa.With(x => x as ContractResultPredicateArgument) .With(x => x.ResultTypeName.FullName) == returnType.GetClrTypeName().FullName)); }
private StaticTypeWrapper MakeType(IDeclaredType typeHandle) { ITypeParameter typeParameterHandle = typeHandle.GetTypeElement() as ITypeParameter; if (typeParameterHandle != null) return MakeGenericParameterType(typeParameterHandle); return MakeDeclaredType(typeHandle); }
internal static bool IsAssignableFrom(this Type type, IDeclaredType c) { return type.FullName == c.GetCLRName() || TypeElementUtil.GetAllSuperTypes(c).Any(superType => type.FullName == superType.GetCLRName()); }
private void ProcessSuperType(XunitTestClassElement classElement, IDeclaredType type) { var @class = type.GetTypeElement() as IClass; if (@class == null) return; foreach (IMethod method in @class.GetMembers().Where(UnitTestElementPsiIdentifier.IsUnitTest)) GetOrCreateMethodElement(classElement, @class, method); }
private StaticDeclaredTypeWrapper MakeDeclaredType(IDeclaredType typeHandle) { return declaredTypeMemoizer.Memoize(typeHandle, () => { ITypeElement typeElement = typeHandle.GetTypeElement(); if (typeElement == null) throw new ReflectionResolveException( String.Format( "Cannot obtain type element for type '{0}' possibly because its source code is not available.", typeHandle.GetCLRName())); return MakeDeclaredType(typeElement, typeHandle.GetSubstitution()); }); }
protected virtual bool ResultIsAlreadyCheckedByContractEnsures( IEnumerable<ContractEnsures> ensureAssertions, IDeclaredType methodReturnType) { Contract.Requires(ensureAssertions != null); Contract.Requires(methodReturnType != null); return ensureAssertions .Any(e => e.ChecksForNotNull( pa => pa.With(x => x as ContractResultPredicateArgument) .With(x => x.ResultTypeName.FullName) == methodReturnType.GetClrName().FullName)); }