Exemplo n.º 1
0
        private DeconstructionVariable BindDeconstructionVariables(
            TypeSymbol declType,
            VariableDesignationSyntax node,
            DiagnosticBag diagnostics)
        {
            switch (node.Kind())
            {
            case SyntaxKind.SingleVariableDesignation:
            {
                var single = (SingleVariableDesignationSyntax)node;
                return(new DeconstructionVariable(BindDeconstructionVariable(declType, single, diagnostics), node));
            }

            case SyntaxKind.DiscardDesignation:
            {
                var discarded = (DiscardDesignationSyntax)node;
                return(new DeconstructionVariable(BindDiscardExpression(discarded, declType), node));
            }

            case SyntaxKind.ParenthesizedVariableDesignation:
            {
                var tuple   = (ParenthesizedVariableDesignationSyntax)node;
                var builder = ArrayBuilder <DeconstructionVariable> .GetInstance();

                foreach (var n in tuple.Variables)
                {
                    builder.Add(BindDeconstructionVariables(declType, n, diagnostics));
                }
                return(new DeconstructionVariable(builder, node));
            }

            default:
                throw ExceptionUtilities.UnexpectedValue(node.Kind());
            }
        }
            private void AddVariableExpressions(
                VariableDesignationSyntax component,
                IList <string> expressions)
            {
                if (!_includeDeclarations)
                {
                    return;
                }

                switch (component.Kind())
                {
                case SyntaxKind.ParenthesizedVariableDesignation:
                {
                    var t = (ParenthesizedVariableDesignationSyntax)component;
                    foreach (var v in t.Variables)
                    {
                        AddVariableExpressions(v, expressions);
                    }
                    break;
                }

                case SyntaxKind.SingleVariableDesignation:
                {
                    var t = (SingleVariableDesignationSyntax)component;
                    expressions.Add(t.Identifier.ValueText);
                    break;
                }
                }
            }
Exemplo n.º 3
0
        internal void CollectLocalsFromDeconstruction(VariableDesignationSyntax designation, TypeSyntax closestTypeSyntax, LocalDeclarationKind kind, ArrayBuilder <LocalSymbol> locals)
        {
            switch (designation.Kind())
            {
            case SyntaxKind.SingleVariableDesignation:
            {
                var single = (SingleVariableDesignationSyntax)designation;
                SourceLocalSymbol localSymbol = SourceLocalSymbol.MakeDeconstructionLocal(
                    this.ContainingMemberOrLambda,
                    this,
                    closestTypeSyntax,
                    single.Identifier,
                    kind);
                locals.Add(localSymbol);
                break;
            }

            case SyntaxKind.ParenthesizedVariableDesignation:
            {
                var tuple = (ParenthesizedVariableDesignationSyntax)designation;
                foreach (var d in tuple.Variables)
                {
                    CollectLocalsFromDeconstruction(d, closestTypeSyntax, kind, locals);
                }
                break;
            }

            default:
                throw ExceptionUtilities.UnexpectedValue(designation.Kind());
            }
        }
Exemplo n.º 4
0
        private void VisitPatternDesignation(VariableDesignationSyntax node)
        {
            switch (node.Kind())
            {
            case SyntaxKind.SingleVariableDesignation:
                TFieldOrLocalSymbol variable = MakePatternVariable(null, (SingleVariableDesignationSyntax)node, _nodeToBind);
                if ((object)variable != null)
                {
                    _variablesBuilder.Add(variable);
                }
                break;

            case SyntaxKind.DiscardDesignation:
                break;

            case SyntaxKind.ParenthesizedVariableDesignation:
                foreach (VariableDesignationSyntax nested in ((ParenthesizedVariableDesignationSyntax)node).Variables)
                {
                    VisitPatternDesignation(nested);
                }
                break;

            default:
                throw ExceptionUtilities.UnexpectedValue(node.Kind());
            }
        }
Exemplo n.º 5
0
        private void CollectVariablesFromDeconstruction(
            VariableDesignationSyntax designation,
            TypeSyntax closestTypeSyntax,
            AssignmentExpressionSyntax deconstruction)
        {
            switch (designation.Kind())
            {
            case SyntaxKind.SingleVariableDesignation:
            {
                var single   = (SingleVariableDesignationSyntax)designation;
                var variable = MakeDeconstructionVariable(closestTypeSyntax, single, deconstruction);
                if ((object)variable != null)
                {
                    _variablesBuilder.Add(variable);
                }
                break;
            }

            case SyntaxKind.ParenthesizedVariableDesignation:
            {
                var tuple = (ParenthesizedVariableDesignationSyntax)designation;
                foreach (var d in tuple.Variables)
                {
                    CollectVariablesFromDeconstruction(d, closestTypeSyntax, deconstruction);
                }
                break;
            }

            case SyntaxKind.DiscardDesignation:
                break;

            default:
                throw ExceptionUtilities.UnexpectedValue(designation.Kind());
            }
        }
Exemplo n.º 6
0
        static Expression Create(Context cx, DeclarationExpressionSyntax node, VariableDesignationSyntax designation, IExpressionParentEntity parent, int child)
        {
            var single = designation as SingleVariableDesignationSyntax;

            if (single != null)
            {
                return(CreateSingle(cx, node, single, parent, child));
            }

            var paren = designation as ParenthesizedVariableDesignationSyntax;

            if (paren != null)
            {
                return(CreateParenthesized(cx, node, paren, parent, child));
            }

            var discard = designation as DiscardDesignationSyntax;

            if (discard != null)
            {
                var type = cx.Model(node).GetTypeInfo(node).Type;
                return(new VariableDeclaration(cx, node, Type.Create(cx, type), node.Type.IsVar, parent, child));
            }

            cx.ModelError(node, "Failed to determine designation type");
            return(new VariableDeclaration(cx, node, null, node.Type.IsVar, parent, child));
        }
 public new void AddChildren()
 {
     base.AddChildren();
     Kind                  = Node.Kind();
     _type                 = ((DeclarationExpressionSyntax)Node).Type;
     _typeIsChanged        = false;
     _designation          = ((DeclarationExpressionSyntax)Node).Designation;
     _designationIsChanged = false;
 }
Exemplo n.º 8
0
        private static async Task RenameVariableAccordingToTypeNameAsync(
            RefactoringContext context,
            DeclarationExpressionSyntax declarationExpression)
        {
            TypeSyntax type = declarationExpression.Type;

            if (type == null)
            {
                return;
            }

            VariableDesignationSyntax designation = declarationExpression.Designation;

            if (designation?.Kind() != SyntaxKind.SingleVariableDesignation)
            {
                return;
            }

            var singleVariableDesignation = (SingleVariableDesignationSyntax)designation;

            SyntaxToken identifier = singleVariableDesignation.Identifier;

            if (!identifier.Span.Contains(context.Span))
            {
                return;
            }

            SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);

            var localSymbol = semanticModel.GetDeclaredSymbol(singleVariableDesignation, context.CancellationToken) as ILocalSymbol;

            if (localSymbol?.IsErrorType() != false)
            {
                return;
            }

            string oldName = identifier.ValueText;

            string newName = NameGenerator.Default.CreateUniqueLocalName(
                localSymbol.Type,
                oldName,
                semanticModel,
                singleVariableDesignation.SpanStart,
                cancellationToken: context.CancellationToken);

            if (newName == null)
            {
                return;
            }

            context.RegisterRefactoring(
                $"Rename '{oldName}' to '{newName}'",
                ct => Renamer.RenameSymbolAsync(context.Solution, localSymbol, newName, default(OptionSet), ct),
                RefactoringDescriptors.RenameIdentifierAccordingToTypeName);
        }
Exemplo n.º 9
0
        private IEnumerable <Diagnostic> Analyze(SemanticModel semanticModel, VariableDesignationSyntax node)
        {
            switch (node)
            {
            case SingleVariableDesignationSyntax s:
                return(AnalyzeIdentifiers(semanticModel, s.Identifier));

            case ParenthesizedVariableDesignationSyntax s:
                return(s.Variables.SelectMany(_ => Analyze(semanticModel, _)));

            default:
                return(Enumerable.Empty <Diagnostic>());
            }
        }
Exemplo n.º 10
0
        public static TypeAnalysisResult AnalyzeType(
            DeclarationExpressionSyntax declarationExpression,
            SemanticModel semanticModel,
            CancellationToken cancellationToken = default(CancellationToken))
        {
            if (declarationExpression == null)
            {
                throw new ArgumentNullException(nameof(declarationExpression));
            }

            if (semanticModel == null)
            {
                throw new ArgumentNullException(nameof(semanticModel));
            }

            TypeSyntax type = declarationExpression.Type;

            if (type != null)
            {
                VariableDesignationSyntax designation = declarationExpression.Designation;

                if (designation != null)
                {
                    SyntaxKind kind = designation.Kind();

                    if (kind == SyntaxKind.ParenthesizedVariableDesignation)
                    {
                        return(TypeAnalysisResult.None);
                    }
                    else if (kind == SyntaxKind.SingleVariableDesignation)
                    {
                        var symbol = semanticModel.GetDeclaredSymbol((SingleVariableDesignationSyntax)designation, cancellationToken) as ILocalSymbol;

                        if (symbol != null)
                        {
                            ITypeSymbol typeSymbol = symbol.Type;

                            if (typeSymbol?.SupportsExplicitDeclaration() == true)
                            {
                                return((type.IsVar)
                                    ? TypeAnalysisResult.ImplicitButShouldBeExplicit
                                    : TypeAnalysisResult.Explicit);
                            }
                        }
                    }
                }
            }

            return(TypeAnalysisResult.None);
        }
Exemplo n.º 11
0
        /// <summary>
        /// Try getting the <see cref="ILocalSymbol"/> for the node.
        /// Gets the semantic model for the tree if the node is not in the tree corresponding to <paramref name="semanticModel"/>.
        /// </summary>
        /// <param name="semanticModel">The <see cref="SemanticModel"/>.</param>
        /// <param name="node">The <see cref="VariableDesignationSyntax"/>.</param>
        /// <param name="cancellationToken">The <see cref="CancellationToken"/>.</param>
        /// <param name="symbol">The symbol if found. Can be <see cref="IDiscardSymbol"/>.</param>
        /// <returns>True if a symbol was found.</returns>
        public static bool TryGetSymbol(this SemanticModel semanticModel, VariableDesignationSyntax node, CancellationToken cancellationToken, [NotNullWhen(true)] out ISymbol?symbol)
        {
            if (semanticModel is null)
            {
                throw new ArgumentNullException(nameof(semanticModel));
            }

            if (node is null)
            {
                throw new ArgumentNullException(nameof(node));
            }

            symbol = GetDeclaredSymbolSafe(semanticModel, node, cancellationToken);
            return(symbol != null);
        }
        private static async Task RenameVariableAccordingToTypeNameAsync(
            RefactoringContext context,
            DeclarationExpressionSyntax declarationExpression)
        {
            TypeSyntax type = declarationExpression.Type;

            if (type != null)
            {
                VariableDesignationSyntax designation = declarationExpression.Designation;

                if (designation?.IsKind(SyntaxKind.SingleVariableDesignation) == true)
                {
                    var singleVariableDesignation = (SingleVariableDesignationSyntax)designation;

                    SyntaxToken identifier = singleVariableDesignation.Identifier;

                    if (identifier.Span.Contains(context.Span))
                    {
                        SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);

                        var localSymbol = semanticModel.GetDeclaredSymbol(singleVariableDesignation, context.CancellationToken) as ILocalSymbol;

                        if (localSymbol?.IsErrorType() == false)
                        {
                            ITypeSymbol typeSymbol = localSymbol.Type;

                            if (typeSymbol != null)
                            {
                                string oldName = identifier.ValueText;
                                string newName = Identifier.CreateName(typeSymbol, firstCharToLower: true);

                                if (!string.IsNullOrEmpty(newName) &&
                                    !string.Equals(oldName, newName, StringComparison.Ordinal))
                                {
                                    newName = Identifier.EnsureUniqueLocalName(newName, singleVariableDesignation.SpanStart, semanticModel, context.CancellationToken);

                                    context.RegisterRefactoring(
                                        $"Rename '{oldName}' to '{newName}'",
                                        cancellationToken => Renamer.RenameSymbolAsync(context.Document, localSymbol, newName, cancellationToken));
                                }
                            }
                        }
                    }
                }
            }
        }
Exemplo n.º 13
0
        static Expression Create(Context cx, DeclarationExpressionSyntax node, VariableDesignationSyntax designation, IExpressionParentEntity parent, int child)
        {
            switch (designation)
            {
            case SingleVariableDesignationSyntax single:
                return(CreateSingle(cx, node, single, parent, child));

            case ParenthesizedVariableDesignationSyntax paren:
                return(CreateParenthesized(cx, node, paren, parent, child));

            case DiscardDesignationSyntax discard:
                var type = cx.Model(discard).GetTypeInfo(discard).Type;
                return(Create(cx, node, Type.Create(cx, type), node.Type.IsVar, parent, child));

            default:
                cx.ModelError(node, "Failed to determine designation type");
                return(Create(cx, node, null, node.Type.IsVar, parent, child));
            }
        }
        internal static async Task ComputeRefactoringAsync(RefactoringContext context, DeclarationPatternSyntax declarationPattern)
        {
            if (context.IsRefactoringEnabled(RefactoringIdentifiers.RenameIdentifierAccordingToTypeName))
            {
                VariableDesignationSyntax designation = declarationPattern.Designation;

                if (designation?.Kind() == SyntaxKind.SingleVariableDesignation)
                {
                    var singleVariableDesignation = (SingleVariableDesignationSyntax)designation;

                    SyntaxToken identifier = singleVariableDesignation.Identifier;

                    if (identifier.Span.Contains(context.Span))
                    {
                        SemanticModel semanticModel = await context.GetSemanticModelAsync().ConfigureAwait(false);

                        ISymbol symbol = semanticModel.GetDeclaredSymbol(singleVariableDesignation, context.CancellationToken);

                        if (symbol?.Kind == SymbolKind.Local)
                        {
                            var localSymbol = (ILocalSymbol)symbol;

                            string oldName = identifier.ValueText;

                            string newName = NameGenerator.Default.CreateUniqueLocalName(
                                localSymbol.Type,
                                oldName,
                                semanticModel,
                                singleVariableDesignation.SpanStart,
                                cancellationToken: context.CancellationToken);

                            if (newName != null)
                            {
                                context.RegisterRefactoring(
                                    $"Rename '{oldName}' to '{newName}'",
                                    cancellationToken => Renamer.RenameSymbolAsync(context.Solution, symbol, newName, default(OptionSet), cancellationToken),
                                    RefactoringIdentifiers.RenameIdentifierAccordingToTypeName);
                            }
                        }
                    }
                }
            }
        }
Exemplo n.º 15
0
        private static void GetLocalNames(VariableDesignationSyntax designation, ref List <SyntaxToken> result)
        {
            switch (designation.Kind())
            {
            case SyntaxKind.SingleVariableDesignation:
                GetLocalNames(((SingleVariableDesignationSyntax)designation).Identifier, ref result);
                return;

            case SyntaxKind.ParenthesizedVariableDesignation:
                var parenthesizedVariableDesignation = (ParenthesizedVariableDesignationSyntax)designation;
                foreach (var variableDesignation in parenthesizedVariableDesignation.Variables)
                {
                    GetLocalNames(variableDesignation, ref result);
                }
                return;

            default: throw ExceptionUtilities.UnexpectedValue(designation.Kind());
            }
        }
Exemplo n.º 16
0
        private void VisitDeclarationExpressionDesignation(
            DeclarationExpressionSyntax node,
            VariableDesignationSyntax designation,
            BaseArgumentListSyntax argumentListSyntaxOpt
            )
        {
            switch (designation.Kind())
            {
            case SyntaxKind.SingleVariableDesignation:
                TFieldOrLocalSymbol variable = MakeDeclarationExpressionVariable(
                    node,
                    (SingleVariableDesignationSyntax)designation,
                    argumentListSyntaxOpt,
                    _nodeToBind
                    );
                if ((object)variable != null)
                {
                    _variablesBuilder.Add(variable);
                }
                break;

            case SyntaxKind.DiscardDesignation:
                break;

            case SyntaxKind.ParenthesizedVariableDesignation:
                foreach (
                    VariableDesignationSyntax nested in (
                        (ParenthesizedVariableDesignationSyntax)designation
                        ).Variables
                    )
                {
                    VisitDeclarationExpressionDesignation(node, nested, argumentListSyntaxOpt);
                }
                break;

            default:
                throw ExceptionUtilities.UnexpectedValue(designation.Kind());
            }
        }
Exemplo n.º 17
0
        private void PopulatePattern(PatternSyntax pattern, TypeSyntax optionalType, VariableDesignationSyntax designation)
        {
            var isVar = optionalType is null;

            switch (designation)
            {
            case SingleVariableDesignationSyntax _:
                if (cx.Model(pattern).GetDeclaredSymbol(designation) is ILocalSymbol symbol)
                {
                    var type = Type.Create(cx, symbol.GetAnnotatedType());
                    Expressions.VariableDeclaration.Create(cx, symbol, type, optionalType, cx.Create(pattern.GetLocation()), cx.Create(designation.GetLocation()), isVar, this, 0);
                }
                break;

            case DiscardDesignationSyntax discard:
                if (isVar)
                {
                    new Expressions.Discard(cx, discard, this, 0);
                }
                else
                {
                    Expressions.TypeAccess.Create(cx, optionalType, this, 0);
                }
                break;

            case null:
                break;

            case ParenthesizedVariableDesignationSyntax paren:
                Expressions.VariableDeclaration.CreateParenthesized(cx, (VarPatternSyntax)pattern, paren, this, 0);
                break;

            default:
                throw new InternalError(pattern, "Unhandled designation in case statement");
            }
        }
Exemplo n.º 18
0
        /// <summary>
        /// Same as SemanticModel.GetDeclaredSymbol but works when <paramref name="node"/> is not in the syntax tree.
        /// </summary>
        /// <param name="semanticModel">The <see cref="SemanticModel"/>.</param>
        /// <param name="node">The <see cref="VariableDesignationSyntax"/>.</param>
        /// <param name="cancellationToken">The <see cref="CancellationToken"/>.</param>
        /// <returns>An <see cref="ISymbol"/> or <see cref="IDiscardSymbol"/> or null.</returns>
        public static ISymbol GetDeclaredSymbolSafe(this SemanticModel semanticModel, VariableDesignationSyntax node, CancellationToken cancellationToken)
        {
            if (node is null)
            {
                return(null);
            }

            switch (node)
            {
            case SingleVariableDesignationSyntax singleVariable:
                return(GetDeclaredSymbolSafe(semanticModel, singleVariable, cancellationToken));

            case DiscardDesignationSyntax discard:
                return(GetDeclaredSymbolSafe(semanticModel, discard, cancellationToken));
            }

            return(null);
        }
Exemplo n.º 19
0
        public static IEnumerable <SingleVariableDesignationSyntax> GetSingleVariableDesignations(this VariableDesignationSyntax designation)
        {
            switch (designation)
            {
            case DiscardDesignationSyntax _:
                yield break;

            case ParenthesizedVariableDesignationSyntax p:
                foreach (var childDesignation in p.Variables)
                {
                    foreach (var singleVariableDesignation in childDesignation.GetSingleVariableDesignations())
                    {
                        yield return(singleVariableDesignation);
                    }
                }
                break;

            case SingleVariableDesignationSyntax singleVariableDesignation:
                yield return(singleVariableDesignation);

                break;

            default:
                throw new ArgumentOutOfRangeException($"Unknown variable designation: {designation}", nameof(designation));
            }
        }
Exemplo n.º 20
0
        private void PopulatePattern(PatternSyntax pattern, TypeSyntax optionalType, SyntaxToken varKeyword, VariableDesignationSyntax designation)
        {
            var isVar = optionalType is null;

            if (!(designation is null) && cx.GetModel(pattern).GetDeclaredSymbol(designation) is ILocalSymbol symbol)
            {
                var type = Entities.Type.Create(cx, symbol.GetAnnotatedType());
                VariableDeclaration.Create(cx, symbol, type, optionalType, cx.Create(pattern.GetLocation()), cx.Create(designation.GetLocation()), isVar, this, 1);
            }
Exemplo n.º 21
0
 // 变量指定
 public virtual void VisitVariableDesignationSyntax(VariableDesignationSyntax value)
 {
     DefaultVisit(value);
 }
 public TameVariableDesignationSyntax(VariableDesignationSyntax node)
 {
     Node = node;
     AddChildren();
 }
            private void AddVariableExpressions(
                VariableDesignationSyntax component,
                IList<string> expressions)
            {
                if (!_includeDeclarations) return;

                switch (component.Kind())
                {
                    case SyntaxKind.ParenthesizedVariableDesignation:
                        {
                            var t = (ParenthesizedVariableDesignationSyntax)component;
                            foreach (VariableDesignationSyntax v in t.Variables) AddVariableExpressions(v, expressions);
                            break;
                        }
                    case SyntaxKind.SingleVariableDesignation:
                        {
                            var t = (SingleVariableDesignationSyntax)component;
                            expressions.Add(t.Identifier.ValueText);
                            break;
                        }
                }
            }
Exemplo n.º 24
0
 private static CasePatternSwitchLabelSyntax CasePatternSwitchLabel(TypeSyntax type, VariableDesignationSyntax designation)
 => SyntaxFactory.CasePatternSwitchLabel(
     SyntaxFactory.DeclarationPattern(type, designation),
     SyntaxFactory.Token(SyntaxKind.ColonToken));
Exemplo n.º 25
0
 internal void CollectLocalsFromDeconstruction(
     VariableDesignationSyntax designation,
     TypeSyntax closestTypeSyntax,
     LocalDeclarationKind kind,
     ArrayBuilder<LocalSymbol> locals,
     SyntaxNode deconstructionStatement,
     Binder enclosingBinderOpt)
 {
     switch (designation.Kind())
     {
         case SyntaxKind.SingleVariableDesignation:
             {
                 var single = (SingleVariableDesignationSyntax)designation;
                 SourceLocalSymbol localSymbol = SourceLocalSymbol.MakeDeconstructionLocal(
                                                             this.ContainingMemberOrLambda,
                                                             this,
                                                             enclosingBinderOpt ?? this,
                                                             closestTypeSyntax,
                                                             single.Identifier,
                                                             kind,
                                                             deconstructionStatement);
                 locals.Add(localSymbol);
                 break;
             }
         case SyntaxKind.ParenthesizedVariableDesignation:
             {
                 var tuple = (ParenthesizedVariableDesignationSyntax)designation;
                 foreach (var d in tuple.Variables)
                 {
                     CollectLocalsFromDeconstruction(d, closestTypeSyntax, kind, locals, deconstructionStatement, enclosingBinderOpt);
                 }
                 break;
             }
         case SyntaxKind.DiscardDesignation:
             break;
         default:
             throw ExceptionUtilities.UnexpectedValue(designation.Kind());
     }
 }
Exemplo n.º 26
0
        private static Expression Create(Context cx, DeclarationExpressionSyntax node, VariableDesignationSyntax designation, IExpressionParentEntity parent, int child)
        {
            switch (designation)
            {
            case SingleVariableDesignationSyntax single:
                return(CreateSingle(cx, node, single, parent, child));

            case ParenthesizedVariableDesignationSyntax paren:
                return(CreateParenthesized(cx, node, paren, parent, child));

            case DiscardDesignationSyntax discard:
                var ti   = cx.GetType(discard);
                var type = Entities.Type.Create(cx, ti);
                return(Create(cx, node, type, parent, child));

            default:
                cx.ModelError(node, "Failed to determine designation type");
                return(Create(cx, node, NullType.Create(cx), parent, child));
            }
        }
Exemplo n.º 27
0
 private DeconstructionVariable BindDeconstructionVariables(
     TypeSymbol declType,
     VariableDesignationSyntax node,
     DiagnosticBag diagnostics)
 {
     switch (node.Kind())
     {
         case SyntaxKind.SingleVariableDesignation:
             {
                 var single = (SingleVariableDesignationSyntax)node;
                 return new DeconstructionVariable(BindDeconstructionVariable(declType, single, diagnostics), node);
             }
         case SyntaxKind.DiscardDesignation:
             {
                 var discarded = (DiscardDesignationSyntax)node;
                 return new DeconstructionVariable(BindDiscardExpression(discarded, declType), node);
             }
         case SyntaxKind.ParenthesizedVariableDesignation:
             {
                 var tuple = (ParenthesizedVariableDesignationSyntax)node;
                 var builder = ArrayBuilder<DeconstructionVariable>.GetInstance();
                 foreach (var n in tuple.Variables)
                 {
                     builder.Add(BindDeconstructionVariables(declType, n, diagnostics));
                 }
                 return new DeconstructionVariable(builder, node);
             }
         default:
             throw ExceptionUtilities.UnexpectedValue(node.Kind());
     }
 }
Exemplo n.º 28
0
 /// <summary>
 /// Try getting the <see cref="ILocalSymbol"/> for the node.
 /// Gets the semantic model for the tree if the node is not in the tree corresponding to <paramref name="semanticModel"/>.
 /// </summary>
 /// <param name="semanticModel">The <see cref="SemanticModel"/>.</param>
 /// <param name="node">The <see cref="VariableDesignationSyntax"/>.</param>
 /// <param name="cancellationToken">The <see cref="CancellationToken"/>.</param>
 /// <param name="symbol">The symbol if found. Can be <see cref="IDiscardSymbol"/>.</param>
 /// <returns>True if a symbol was found.</returns>
 public static bool TryGetSymbol(this SemanticModel semanticModel, VariableDesignationSyntax node, CancellationToken cancellationToken, out ISymbol symbol)
 {
     symbol = GetDeclaredSymbolSafe(semanticModel, node, cancellationToken);
     return(symbol != null);
 }
Exemplo n.º 29
0
        private void PopulatePattern(PatternSyntax pattern, TypeSyntax optionalType, SyntaxToken varKeyword, VariableDesignationSyntax designation)
        {
            var isVar = optionalType is null;

            if (!isVar)
            {
                Expressions.TypeAccess.Create(cx, optionalType, this, 1);
            }

            switch (designation)
            {
            case SingleVariableDesignationSyntax _:
                if (cx.Model(pattern).GetDeclaredSymbol(designation) is ILocalSymbol symbol)
                {
                    var type = Type.Create(cx, symbol.Type);

                    if (isVar)
                    {
                        new Expression(new ExpressionInfo(cx, type, cx.Create(varKeyword.GetLocation()), ExprKind.TYPE_ACCESS, this, 1, false, null));
                    }

                    Expressions.VariableDeclaration.Create(cx, symbol, type, cx.Create(pattern.GetLocation()), cx.Create(designation.GetLocation()), isVar, this, 0);
                }
                break;

            case DiscardDesignationSyntax discard:
                new Expressions.Discard(cx, discard, this, 0);
                break;

            case null:
                break;

            case ParenthesizedVariableDesignationSyntax paren:
                Expressions.VariableDeclaration.CreateParenthesized(cx, (VarPatternSyntax)pattern, paren, this, 0);
                break;

            default:
                throw new InternalError(pattern, "Unhandled designation in case statement");
            }
        }
Exemplo n.º 30
0
        public static TypeAnalysisFlags AnalyzeType(
            DeclarationExpressionSyntax declarationExpression,
            SemanticModel semanticModel,
            CancellationToken cancellationToken = default(CancellationToken))
        {
            if (declarationExpression == null)
            {
                throw new ArgumentNullException(nameof(declarationExpression));
            }

            if (semanticModel == null)
            {
                throw new ArgumentNullException(nameof(semanticModel));
            }

            TypeSyntax type = declarationExpression.Type;

            if (type != null)
            {
                VariableDesignationSyntax designation = declarationExpression.Designation;

                if (designation?.IsKind(SyntaxKind.SingleVariableDesignation) == true)
                {
                    var symbol = semanticModel.GetDeclaredSymbol((SingleVariableDesignationSyntax)designation, cancellationToken) as ILocalSymbol;

                    if (symbol?.IsErrorType() == false)
                    {
                        ITypeSymbol typeSymbol = symbol.Type;

                        if (typeSymbol?.IsErrorType() == false)
                        {
                            var flags = TypeAnalysisFlags.None;

                            if (typeSymbol.IsDynamicType())
                            {
                                flags = TypeAnalysisFlags.Dynamic;
                            }
                            else
                            {
                                flags = TypeAnalysisFlags.ValidSymbol;

                                if (type.IsVar)
                                {
                                    flags |= TypeAnalysisFlags.Implicit;

                                    if (symbol.Type.SupportsExplicitDeclaration())
                                    {
                                        flags |= TypeAnalysisFlags.SupportsExplicit;
                                    }
                                }
                                else
                                {
                                    flags |= TypeAnalysisFlags.Explicit;
                                    flags |= TypeAnalysisFlags.SupportsImplicit;
                                }
                            }

                            return(flags);
                        }
                    }
                }
            }

            return(TypeAnalysisFlags.None);
        }
Exemplo n.º 31
0
        private void PopulatePattern(PatternSyntax pattern, TypeSyntax optionalType, SyntaxToken varKeyword, VariableDesignationSyntax designation)
        {
            bool isVar = optionalType is null;

            if (!isVar)
            {
                Expressions.TypeAccess.Create(cx, optionalType, this, 1);
            }

            if (!(designation is null) && cx.Model(pattern).GetDeclaredSymbol(designation) is ILocalSymbol symbol)
            {
                var type = Type.Create(cx, symbol.Type);

                if (isVar)
                {
                    new Expression(new ExpressionInfo(cx, type, cx.Create(varKeyword.GetLocation()), ExprKind.TYPE_ACCESS, this, 1, false, null));
                }

                VariableDeclaration.Create(cx, symbol, type, cx.Create(pattern.GetLocation()), cx.Create(designation.GetLocation()), isVar, this, 2);
            }
        }