Example #1
0
        public static CanInstantiate CanInstantiateType([NotNull] ITypeElement typeElement,
                                                    [NotNull] ITreeNode expression)
        {
            if (typeElement is IStruct || typeElement is IEnum || typeElement is IClass)
              {
            // filter out abstract classes
            var classType = typeElement as IClass;
            if (classType != null && classType.IsAbstract)
              return CanInstantiate.No;

            // check type has any constructor accessible
            var accessContext = new ElementAccessContext(expression);
            var canInstantiate = CanInstantiate.No;

            foreach (var constructor in typeElement.Constructors)
            {
              if (constructor.IsStatic) continue;
              if (AccessUtil.IsSymbolAccessible(constructor, accessContext))
              {
            var parametersCount = constructor.Parameters.Count;
            canInstantiate |= (parametersCount == 0)
              ? CanInstantiate.DefaultConstructor
              : CanInstantiate.ConstructorWithParameters;
              }
            }

            return canInstantiate;
              }

              return CanInstantiate.No;
        }
Example #2
0
        public static TypeInstantiability IsInstantiable(
      [NotNull] ITypeElement typeElement, [NotNull] ITreeNode expression)
        {
            if (typeElement is IStruct || typeElement is IEnum || typeElement is IClass)
              {
            // filter out abstract classes
            var classType = typeElement as IClass;
            if (classType != null && classType.IsAbstract)
              return TypeInstantiability.NotInstantiable;

            // check type has any constructor accessable
            var accessContext = new ElementAccessContext(expression);

            var instantiability = TypeInstantiability.NotInstantiable;
            foreach (var constructor in typeElement.Constructors)
            {
              if (constructor.IsStatic) continue;
              if (AccessUtil.IsSymbolAccessible(constructor, accessContext))
              {
            var parametersCount = constructor.Parameters.Count;
            instantiability |= (parametersCount == 0)
              ? TypeInstantiability.DefaultCtor
              : TypeInstantiability.CtorWithParameters;
              }
            }

            return instantiability;
              }

              return TypeInstantiability.NotInstantiable;
        }
Example #3
0
        public static CanInstantiate CanInstantiateType([NotNull] ITypeElement typeElement, [NotNull] ITreeNode expression)
        {
            if (typeElement is IStruct || typeElement is IEnum || typeElement is IClass)
            {
                // filter out abstract classes
                var classType = typeElement as IClass;
                if (classType != null && classType.IsAbstract)
                {
                    return(CanInstantiate.No);
                }

                // check type has any constructor accessible
                var accessContext  = new ElementAccessContext(expression);
                var canInstantiate = CanInstantiate.No;

                foreach (var constructor in typeElement.Constructors)
                {
                    if (constructor.IsStatic)
                    {
                        continue;
                    }
                    if (AccessUtil.IsSymbolAccessible(constructor, accessContext))
                    {
                        var parametersCount = constructor.Parameters.Count;
                        canInstantiate |= (parametersCount == 0)
              ? CanInstantiate.DefaultConstructor
              : CanInstantiate.ConstructorWithParameters;
                    }
                }

                return(canInstantiate);
            }

            return(CanInstantiate.No);
        }
        private static ElementAccessContext CreateContext <TSyntaxNodeType>(string testInput, int skip, AnalyzerLanguage language) where TSyntaxNodeType : SyntaxNode
        {
            var testCode = new SnippetCompiler(testInput, true, language);
            var node     = testCode.GetNodes <TSyntaxNodeType>().Skip(skip).First();
            var context  = new ElementAccessContext(testCode.CreateAnalysisContext(node));

            return(context);
        }
        public void CreateItems(PostfixTemplateAcceptanceContext context, ICollection<ILookupItem> consumer)
        {
            var typeElement = context.ExpressionReferencedElement as ITypeElement;
              if (typeElement is IStruct || typeElement is IEnum || typeElement is IClass)
              {
            // filter out abstract classes
            var classType = typeElement as IClass;
            if (classType != null && classType.IsAbstract) return;

            // check type has any constructor accessable
            var accessContext = new ElementAccessContext(context.Expression);
            foreach (var constructor in typeElement.Constructors)
            {
              if (!constructor.IsStatic && AccessUtil.IsSymbolAccessible(constructor, accessContext))
              {
            consumer.Add(new PostfixLookupItem(context, "new", "new $EXPR$($CARET$)"));
            break;
              }
            }
              }
        }