return "AddInput";
  }
}

std::vector<string> ArgView::SetterArgs() const { return {VariableName()}; }

bool ArgView::IsList() const { return arg_.arg_type().is_list(); }

int ArgView::Position() const { return arg_.position(); }

}  // namespace cpp
}  // namespace generator

     * @param position
     *            読み込みを開始する位置
     * @return 読み込んだバイト数
     */
    public static int read(final FileChannel channel, final ByteBuffer buffer, final long position) {
        assertArgumentNotNull("channel", channel);
        assertArgumentNotNull("buffer", buffer);

        try {
            return channel.read(buffer, position);
        } catch (final IOException e) {

                    val receiverSmartCasts = expression.getImplicitReceiverSmartCast()
                    for (receiverSmartCast in receiverSmartCasts) {
                        appendLine("receiver: ${receiverSmartCast.kind}")
                        appendLine("    smartCastType: ${receiverSmartCast.type.render(position = Variance.INVARIANT)}")
                    }

        }
    }

    override fun doTestByMainFile(mainFile: KtFile, mainModule: KtTestModule, testServices: TestServices) {
        val position = testServices.expressionMarkerProvider.getCaretPosition(mainFile)
        val reference = mainFile.findReferenceAt(position)
        assertNotNull(reference)
        val expectedAlias = mainModule.testModule.directives.singleValue(Directives.TYPE_ALIAS)

) : KaSymbolDeclarationRendererProvider() {

    override fun renderType(type: KaType, renderer: KaTypeRenderer, position: Variance): String {
        return with(analysisSession) {
            val approximatedType = KaRendererTypeApproximator.TO_DENOTABLE.approximateType(analysisSession, type, position)
            prettyPrint { renderer.renderType(analysisSession, approximatedType, this) }
        }
    }

	imports              []rawImport
	embeds               []embed
	directives           []build.Directive
}

type rawImport struct {
	path     string
	position token.Position
}

type embed struct {
	pattern  string
	position token.Position
}

// importRaw fills the rawPackage from the package files in srcDir.
// dir is the package's path relative to the modroot.

    override val token: KaLifetimeToken
        get() = analysisSession.token

    override fun isVisible(
        candidateSymbol: KaSymbolWithVisibility,
        useSiteFile: KaFileSymbol,
        position: PsiElement,
        receiverExpression: KtExpression?
    ): Boolean {
        if (candidateSymbol.visibility == Visibilities.Public) {
            return true
        }

                                    append(it.returnType.render(typeRenderer, position = Variance.IN_VARIANCE))
                                }
                                append(": ${signature.returnType.render(typeRenderer, position = Variance.OUT_VARIANCE)}")
                            }
                        }
                    }
                }
            }

type IndexExpr struct {
	Orig    ast.Expr   // the wrapped expr, which may be distinct from the IndexListExpr below.
	X       ast.Expr   // expression
	Lbrack  token.Pos  // position of "["
	Indices []ast.Expr // index expressions
	Rbrack  token.Pos  // position of "]"
}

func (x *IndexExpr) Pos() token.Pos {
	return x.Orig.Pos()
}

func UnpackIndexExpr(n ast.Node) *IndexExpr {
	switch e := n.(type) {
	case *ast.IndexExpr:

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package markdown

import (
	"bytes"
	"fmt"
	"strings"
)

type Heading struct {
	Position
	Level int
	Text  *Text
	// The HTML id attribute. The parser populates this field if
	// [Parser.HeadingIDs] is true and the heading ends with text like "{#id}".
	ID string
}