public override void VisitIndexerDeclaration(IndexerDeclarationSyntax node)
 {
     CheckXmlDocForErrors(node, semanticModel.GetDeclaredSymbol(node));
 }

 /// <summary>
 /// Given a syntax node that declares an indexer, get the corresponding declared symbol.
 /// </summary>
 /// <param name="declarationSyntax">The syntax node that declares an indexer.</param>
 /// <param name="cancellationToken">The cancellation token.</param>
 /// <returns>The symbol that was declared.</returns>
 public override IPropertySymbol GetDeclaredSymbol(IndexerDeclarationSyntax declarationSyntax, CancellationToken cancellationToken = default(CancellationToken))
 {
     return (IPropertySymbol)GetDeclaredMemberSymbol(declarationSyntax);
 }

 public override void VisitIndexerDeclaration(IndexerDeclarationSyntax node)
 {
     base.VisitIndexerDeclaration(node);
     Chunk.AddFunction(node, Model);
 }

 public override SyntaxNode VisitIndexerDeclaration(IndexerDeclarationSyntax node)
 {
     this.AppendCompileIssue(node, IssueType.Error, IssueId.IndexerNotSupport);
     return node;
 }

        private static SyntaxNode HandleIndexerDeclaration(IndexerDeclarationSyntax node)
        {
            TypeSyntax type = node.Type;
            if (type == null || type.IsMissing)
            {
                return null;
            }

            SyntaxTokenList modifiers = DeclarationModifiersHelper.AddModifier(node.Modifiers, ref type, SyntaxKind.PrivateKeyword);
            return node
                .WithType(type)
                .WithModifiers(modifiers)
                .WithoutFormatting();
        }

		/// <summary>
		///   Normalizes the <paramref name="declaration" />.
		/// </summary>
		public override SyntaxNode VisitIndexerDeclaration(IndexerDeclarationSyntax declaration)
		{
			// Nothing to do here for properties without expression bodies
			if (declaration.ExpressionBody == null)
				return declaration;

			// Nothing to do here for indexers not defined in fault effects or for indexers that are no overrides of some port
			var propertySymbol = declaration.GetPropertySymbol(SemanticModel);
			if (!propertySymbol.ContainingType.IsFaultEffect(SemanticModel) || !propertySymbol.IsOverride)
				return declaration;

			var originalDeclaration = declaration;
			var statements = AsStatementBody(propertySymbol.GetMethod, declaration.ExpressionBody.Expression);

			var getter = SyntaxFactory.AccessorDeclaration(SyntaxKind.GetAccessorDeclaration, statements);
			var accessorList = SyntaxFactory.AccessorList(SyntaxFactory.SingletonList(getter));
			declaration = declaration.WithAccessorList(accessorList);

			declaration = declaration.WithExpressionBody(null).WithSemicolonToken(default(SyntaxToken));
			return declaration.EnsureLineCount(originalDeclaration);
		}

            public override void VisitIndexerDeclaration(IndexerDeclarationSyntax node)
            {
                base.VisitIndexerDeclaration(node);

                if (node.Modifiers.Any(m => m.IsKind(SyntaxKind.ExternKeyword)))
                {
                    // This method body is unable to be analysed, so may contain writer instances
                    CheckForRefParametersForExternMethod(node.ParameterList.Parameters);
                }
            }

 public IndexerDeclarationTranslation(IndexerDeclarationSyntax syntax, SyntaxTranslation parent) : base(syntax, parent)
 {
     ParameterList = syntax.ParameterList.Get<BracketedParameterListTranslation>(this);
 }

 /// <summary>
 /// Given a syntax node that declares an indexer, get the corresponding declared symbol.
 /// </summary>
 /// <param name="declarationSyntax">The syntax node that declares an indexer.</param>
 /// <param name="cancellationToken">The cancellation token.</param>
 /// <returns>The symbol that was declared.</returns>
 public override IPropertySymbol GetDeclaredSymbol(IndexerDeclarationSyntax declarationSyntax, CancellationToken cancellationToken = default(CancellationToken))
 {
     using (Logger.LogBlock(FunctionId.CSharp_SemanticModel_GetDeclaredSymbol, message: this.SyntaxTree.FilePath, cancellationToken: cancellationToken))
     {
         return (IPropertySymbol)GetDeclaredMemberSymbol(declarationSyntax);
     }
 }

 /// <summary>
 /// A position is inside a property body only if it is inside an expression body.
 /// All block bodies for properties are part of the accessor declaration (a type
 /// of BaseMethodDeclaration), not the property declaration.
 /// </summary>
 internal static bool IsInBody(int position,
     IndexerDeclarationSyntax indexer)
     => IsInBody(position, default(BlockSyntax), indexer.GetExpressionBodySyntax(), indexer.SemicolonToken);

        private async Task<Document> HandleIndexerDeclaration(IndexerDeclarationSyntax declaration, Document document, CancellationToken cancellationToken)
        {
            var returnStatement = SyntaxFactory.ReturnStatement(
                returnKeyword: SyntaxFactory.Token(SyntaxKind.ReturnKeyword),
                expression: declaration.ExpressionBody.Expression,
                semicolonToken: declaration.SemicolonToken);

            var accessorDeclaration = SyntaxFactory.AccessorDeclaration(
                kind: SyntaxKind.GetAccessorDeclaration,
                body: SyntaxFactory.Block(returnStatement));

            var newDeclaration = declaration
                .WithAccessorList(
                    SyntaxFactory.AccessorList(
                        SyntaxFactory.SingletonList(accessorDeclaration)))
                .WithExpressionBody(null)
                .WithSemicolonToken(default(SyntaxToken))
                .WithAdditionalAnnotations(Formatter.Annotation);

            var oldRoot = await document.GetSyntaxRootAsync(cancellationToken);
            var newRoot = oldRoot.ReplaceNode(declaration, newDeclaration);

            return document.WithSyntaxRoot(newRoot);
        }

 /// <summary>
 /// 
 /// </summary>
 /// <param name="node"></param>
 public override sealed void VisitIndexerDeclaration(IndexerDeclarationSyntax node)
 {
     this.OnNodeVisited(node, this.type.IsInstanceOfType(node));
     base.VisitIndexerDeclaration(node);
 }

 /// <summary>
 /// 
 /// </summary>
 /// <param name="node"></param>
 public override sealed void VisitIndexerDeclaration(IndexerDeclarationSyntax node)
 {
     this.OnNodeVisited(node);
     if (!this.traverseRootOnly) base.VisitIndexerDeclaration(node);
 }

            public void Add(IndexerDeclarationSyntax node)
            {
                if (IsLibrary)
                    return;

                ISymbol s = Model.GetDeclaredSymbol(node);
                Function fGet = null;
                Function fSet = null;

                string sGet = string.Empty;
                string sSet = string.Empty;
                IMethodSymbol msGet = null;
                IMethodSymbol msSet = null;
                foreach (AccessorDeclarationSyntax ads in node.AccessorList.Accessors)
                {
                    switch (ads.Keyword.CSharpKind())
                    {
                        case SyntaxKind.GetKeyword:
                            {
                                msGet = Model.GetDeclaredSymbol(ads);
                                if (!Chunk.Functions.TryGetValue(msGet, out fGet))
                                {
                                    throw new LS2ILMethodException("Method not found " + msGet.ToString());
                                }
                                sGet = /*"get_" +*/ msGet.GetFullyQualifiedName();
                            }
                            break;
                        case SyntaxKind.SetKeyword:
                            {
                                msSet = Model.GetDeclaredSymbol(ads);
                                if (!Chunk.Functions.TryGetValue(msSet, out fSet))
                                {
                                    throw new LS2ILMethodException("Method not found " + msSet.ToString());
                                }
                                sSet = /*"set_" +*/ msSet.GetFullyQualifiedName();
                            }
                            break;
                        default:
                            throw new NotImplementedException("unhandled property accessor: " + ads.Keyword.CSharpKind().ToString());
                            break;
                    }
                }

                if (msGet != null)
                {
                    FlatArrayBuilder fab = new FlatArrayBuilder();
                    fab.Add(FlatValue.Int32(s.IsStatic ? (int)ClassMemberType.StaticMethod : (int)ClassMemberType.Method));

                    fab.Add(FlatValue.String(sGet));
                    Function f;
                    if (!Chunk.Functions.TryGetValue(msGet, out f))
                    {
                        throw new LS2ILMethodException("Method not found " + msGet.ToString());
                    }

                    fab.Add(FlatValue.Int32(f.NumFunction));

                    fab.Add(GenerateInputDeclarations(msGet).GetFlatValue());

                    Members.Add(fab.GetFlatValue());
                }
                if (msSet != null)
                {
                    FlatArrayBuilder fab = new FlatArrayBuilder();
                    fab.Add(FlatValue.Int32(s.IsStatic ? (int)ClassMemberType.StaticMethod : (int)ClassMemberType.Method));

                    fab.Add(FlatValue.String(sSet));
                    Function f;
                    if (!Chunk.Functions.TryGetValue(msSet, out f))
                    {
                        throw new LS2ILMethodException("Method not found " + msGet.ToString());
                    }

                    fab.Add(FlatValue.Int32(f.NumFunction));

                    fab.Add(GenerateInputDeclarations(msSet).GetFlatValue());

                    Members.Add(fab.GetFlatValue());
                }
            }

        public void AddFunction(IndexerDeclarationSyntax node, SemanticModel Model)
        {
            IPropertySymbol ps = Model.GetDeclaredSymbol(node);
            foreach(AccessorDeclarationSyntax ads in node.AccessorList.Accessors)
            {
                IMethodSymbol ms = Model.GetDeclaredSymbol(ads);
                AddFunction(ms, Model);
            }

            /*
            Function f;
            if (Indexers.TryGetValue(ms, out f))
            {
                return;
            }
            int nFunction = FunctionsByNumber.Count;
            f = new Function(this, nFunction, Model, ms);
            Functions.Add(f.IMethodSymbol, f);
            FunctionsByNumber.Add(f);

            if (ms.IsImplicitlyDeclared)
            {
                TypeExtraInfo tei = AddTypeExtraInfo(ms.ContainingType, Model, false); // assuming isLibrary=false because we have a function representing it in the chunk.
                tei.MetadataGenerator.Add(ms);
            }
            /**/
        }

 public override SyntaxNode VisitIndexerDeclaration(IndexerDeclarationSyntax node)
 {
     if (node == null)
         return null;
     var symbol = m_model.GetDeclaredSymbol(node);
     node = (IndexerDeclarationSyntax)base.VisitIndexerDeclaration(node);
     if (!IsPrivateOrInternal(symbol.DeclaredAccessibility))
         node = (IndexerDeclarationSyntax)ApplyDocComment(node, symbol.GetDocumentationCommentId());
     return node;
 }

        private static Document GetTransformedDocumentForIndexerDeclaration(Document document, Diagnostic diagnostic, SyntaxNode root, SemanticModel semanticModel, IndexerDeclarationSyntax indexerDeclaration, CancellationToken cancellationToken)
        {
            if (indexerDeclaration.ExplicitInterfaceSpecifier == null && !indexerDeclaration.Modifiers.Any(SyntaxKind.OverrideKeyword))
            {
                ISymbol declaredSymbol = semanticModel.GetDeclaredSymbol(indexerDeclaration, cancellationToken);
                if (declaredSymbol == null || !NamedTypeHelpers.IsImplementingAnInterfaceMember(declaredSymbol))
                {
                    return document;
                }
            }

            return InsertInheritdocComment(document, diagnostic, root, indexerDeclaration, cancellationToken);
        }

        private static IndexerDeclarationSyntax UseExpressionBodyIfDesired(
            Workspace workspace, IndexerDeclarationSyntax declaration, ParseOptions options)
        {
            if (declaration.ExpressionBody == null)
            {
                var preferExpressionBody = workspace.Options.GetOption(CSharpCodeStyleOptions.PreferExpressionBodiedIndexers).Value;
                if (preferExpressionBody)
                {
                    var expressionBody = TryGetExpressionBody(declaration.AccessorList, options);
                    if (expressionBody != null)
                    {
                        declaration = declaration.WithAccessorList(null)
                                                 .WithExpressionBody(expressionBody)
                                                 .WithSemicolonToken(SyntaxFactory.Token(SyntaxKind.SemicolonToken));
                    }
                }
            }

            return declaration;
        }

 public static void Go(OutputWriter writer, IndexerDeclarationSyntax property, bool isProxy = false)
 {
     WriteProperty.Go(writer, property, isProxy);
 }

 public override IPropertySymbol GetDeclaredSymbol(IndexerDeclarationSyntax declarationSyntax, CancellationToken cancellationToken = default(CancellationToken))
 {
     // Can't define indexer inside member.
     return null;
 }