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; } } }
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()); } }
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()); } }
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()); } }
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; }
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); }
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>()); } }
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); }
/// <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)); } } } } } } }
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); } } } } } }
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()); } }
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()); } }
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"); } }
/// <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); }
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)); } }
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); }
// 变量指定 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; } } }
private static CasePatternSwitchLabelSyntax CasePatternSwitchLabel(TypeSyntax type, VariableDesignationSyntax designation) => SyntaxFactory.CasePatternSwitchLabel( SyntaxFactory.DeclarationPattern(type, designation), SyntaxFactory.Token(SyntaxKind.ColonToken));
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()); } }
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)); } }
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()); } }
/// <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); }
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"); } }
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); }
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); } }