_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q5900 | NewBooleanAnd | train | func NewBooleanAnd(Variable node.Node, Expression node.Node) *BooleanAnd {
return &BooleanAnd{
FreeFloating: nil,
Left: Variable,
Right: Expression,
}
} | go | {
"resource": ""
} |
q5901 | NewFunctionCall | train | func NewFunctionCall(Function node.Node, ArgumentList *node.ArgumentList) *FunctionCall {
return &FunctionCall{
FreeFloating: nil,
Function: Function,
ArgumentList: ArgumentList,
}
} | go | {
"resource": ""
} |
q5902 | NewParameter | train | func NewParameter(VariableType Node, Variable Node, DefaultValue Node, ByRef bool, Variadic bool) *Parameter {
return &Parameter{
FreeFloating: nil,
ByRef: ByRef,
Variadic: Variadic,
VariableType: VariableType,
Variable: Variable,
DefaultValue: DefaultValue,
}
} | go | {
"resource": ""
} |
q5903 | NewBooleanOr | train | func NewBooleanOr(Variable node.Node, Expression node.Node) *BooleanOr {
return &BooleanOr{
FreeFloating: nil,
Left: Variable,
Right: Expression,
}
} | go | {
"resource": ""
} |
q5904 | NewEmpty | train | func NewEmpty(Expression node.Node) *Empty {
return &Empty{
FreeFloating: nil,
Expr: Expression,
}
} | go | {
"resource": ""
} |
q5905 | NewDo | train | func NewDo(Stmt node.Node, Cond node.Node) *Do {
return &Do{
FreeFloating: nil,
Stmt: Stmt,
Cond: Cond,
}
} | go | {
"resource": ""
} |
q5906 | NewGroupUse | train | func NewGroupUse(UseType node.Node, Prefix node.Node, UseList []node.Node) *GroupUse {
return &GroupUse{
FreeFloating: nil,
UseType: UseType,
Prefix: Prefix,
UseList: UseList,
}
} | go | {
"resource": ""
} |
q5907 | NewClass | train | func NewClass(ClassName node.Node, Modifiers []node.Node, ArgumentList *node.ArgumentList, Extends *ClassExtends, Implements *ClassImplements, Stmts []node.Node, PhpDocComment string) *Class {
return &Class{
FreeFloating: nil,
PhpDocComment: PhpDocComment,
ClassName: ClassName,
Modifiers: Modifiers,
... | go | {
"resource": ""
} |
q5908 | NewParser | train | func NewParser(src io.Reader, path string) *Parser {
lexer := scanner.NewLexer(src, path)
return &Parser{
lexer,
path,
nil,
nil,
nil,
}
} | go | {
"resource": ""
} |
q5909 | Lex | train | func (l *Parser) Lex(lval *yySymType) int {
t := l.Lexer.Lex(lval)
l.currentToken = lval.token
return t
} | go | {
"resource": ""
} |
q5910 | Parse | train | func (l *Parser) Parse() int {
// init
l.Lexer.Errors = nil
l.rootNode = nil
l.positionBuilder = &parser.PositionBuilder{}
// parse
return yyParse(l)
} | go | {
"resource": ""
} |
q5911 | NewBooleanNot | train | func NewBooleanNot(Expression node.Node) *BooleanNot {
return &BooleanNot{
FreeFloating: nil,
Expr: Expression,
}
} | go | {
"resource": ""
} |
q5912 | NewPreDec | train | func NewPreDec(Variable node.Node) *PreDec {
return &PreDec{
FreeFloating: nil,
Variable: Variable,
}
} | go | {
"resource": ""
} |
q5913 | NewFunction | train | func NewFunction(FunctionName node.Node, ReturnsRef bool, Params []node.Node, ReturnType node.Node, Stmts []node.Node, PhpDocComment string) *Function {
return &Function{
FreeFloating: nil,
ReturnsRef: ReturnsRef,
PhpDocComment: PhpDocComment,
FunctionName: FunctionName,
Params: Params,
ReturnT... | go | {
"resource": ""
} |
q5914 | NewPostDec | train | func NewPostDec(Variable node.Node) *PostDec {
return &PostDec{
FreeFloating: nil,
Variable: Variable,
}
} | go | {
"resource": ""
} |
q5915 | NewAltWhile | train | func NewAltWhile(Cond node.Node, Stmt node.Node) *AltWhile {
return &AltWhile{
FreeFloating: nil,
Cond: Cond,
Stmt: Stmt,
}
} | go | {
"resource": ""
} |
q5916 | NewErrorSuppress | train | func NewErrorSuppress(Expression node.Node) *ErrorSuppress {
return &ErrorSuppress{
FreeFloating: nil,
Expr: Expression,
}
} | go | {
"resource": ""
} |
q5917 | NewFullyQualified | train | func NewFullyQualified(Parts []node.Node) *FullyQualified {
return &FullyQualified{
FreeFloating: nil,
Parts: Parts,
}
} | go | {
"resource": ""
} |
q5918 | NewExpression | train | func NewExpression(Expr node.Node) *Expression {
return &Expression{
FreeFloating: nil,
Expr: Expr,
}
} | go | {
"resource": ""
} |
q5919 | NewClassConstList | train | func NewClassConstList(Modifiers []node.Node, Consts []node.Node) *ClassConstList {
return &ClassConstList{
FreeFloating: nil,
Modifiers: Modifiers,
Consts: Consts,
}
} | go | {
"resource": ""
} |
q5920 | NewBitwiseXor | train | func NewBitwiseXor(Variable node.Node, Expression node.Node) *BitwiseXor {
return &BitwiseXor{
FreeFloating: nil,
Variable: Variable,
Expression: Expression,
}
} | go | {
"resource": ""
} |
q5921 | NewLogicalAnd | train | func NewLogicalAnd(Variable node.Node, Expression node.Node) *LogicalAnd {
return &LogicalAnd{
FreeFloating: nil,
Left: Variable,
Right: Expression,
}
} | go | {
"resource": ""
} |
q5922 | NewVariable | train | func NewVariable(VarName node.Node) *Variable {
return &Variable{
FreeFloating: nil,
VarName: VarName,
}
} | go | {
"resource": ""
} |
q5923 | NewDouble | train | func NewDouble(Expr node.Node) *Double {
return &Double{
FreeFloating: nil,
Expr: Expr,
}
} | go | {
"resource": ""
} |
q5924 | NewLogicalOr | train | func NewLogicalOr(Variable node.Node, Expression node.Node) *LogicalOr {
return &LogicalOr{
FreeFloating: nil,
Left: Variable,
Right: Expression,
}
} | go | {
"resource": ""
} |
q5925 | NewUnaryPlus | train | func NewUnaryPlus(Expression node.Node) *UnaryPlus {
return &UnaryPlus{
FreeFloating: nil,
Expr: Expression,
}
} | go | {
"resource": ""
} |
q5926 | NewLogicalXor | train | func NewLogicalXor(Variable node.Node, Expression node.Node) *LogicalXor {
return &LogicalXor{
FreeFloating: nil,
Left: Variable,
Right: Expression,
}
} | go | {
"resource": ""
} |
q5927 | NewShortArray | train | func NewShortArray(Items []node.Node) *ShortArray {
return &ShortArray{
FreeFloating: nil,
Items: Items,
}
} | go | {
"resource": ""
} |
q5928 | NewMod | train | func NewMod(Variable node.Node, Expression node.Node) *Mod {
return &Mod{
FreeFloating: nil,
Variable: Variable,
Expression: Expression,
}
} | go | {
"resource": ""
} |
q5929 | NewFinally | train | func NewFinally(Stmts []node.Node) *Finally {
return &Finally{
FreeFloating: nil,
Stmts: Stmts,
}
} | go | {
"resource": ""
} |
q5930 | NewConstList | train | func NewConstList(Consts []node.Node) *ConstList {
return &ConstList{
FreeFloating: nil,
Consts: Consts,
}
} | go | {
"resource": ""
} |
q5931 | NewExit | train | func NewExit(Expr node.Node) *Exit {
return &Exit{
FreeFloating: nil,
Expr: Expr,
}
} | go | {
"resource": ""
} |
q5932 | NewFor | train | func NewFor(Init []node.Node, Cond []node.Node, Loop []node.Node, Stmt node.Node) *For {
return &For{
FreeFloating: nil,
Init: Init,
Cond: Cond,
Loop: Loop,
Stmt: Stmt,
}
} | go | {
"resource": ""
} |
q5933 | NewUseList | train | func NewUseList(UseType node.Node, Uses []node.Node) *UseList {
return &UseList{
FreeFloating: nil,
UseType: UseType,
Uses: Uses,
}
} | go | {
"resource": ""
} |
q5934 | NewLabel | train | func NewLabel(LabelName node.Node) *Label {
return &Label{
FreeFloating: nil,
LabelName: LabelName,
}
} | go | {
"resource": ""
} |
q5935 | NewName | train | func NewName(Parts []node.Node) *Name {
return &Name{
FreeFloating: nil,
Parts: Parts,
}
} | go | {
"resource": ""
} |
q5936 | NewIf | train | func NewIf(Cond node.Node, Stmt node.Node, ElseIf []node.Node, Else node.Node) *If {
return &If{
FreeFloating: nil,
Cond: Cond,
Stmt: Stmt,
ElseIf: ElseIf,
Else: Else,
}
} | go | {
"resource": ""
} |
q5937 | AddElseIf | train | func (n *If) AddElseIf(ElseIf node.Node) node.Node {
if n.ElseIf == nil {
n.ElseIf = make([]node.Node, 0)
}
n.ElseIf = append(n.ElseIf, ElseIf)
return n
} | go | {
"resource": ""
} |
q5938 | SetElse | train | func (n *If) SetElse(Else node.Node) node.Node {
n.Else = Else
return n
} | go | {
"resource": ""
} |
q5939 | NewTrait | train | func NewTrait(TraitName node.Node, Stmts []node.Node, PhpDocComment string) *Trait {
return &Trait{
FreeFloating: nil,
PhpDocComment: PhpDocComment,
TraitName: TraitName,
Stmts: Stmts,
}
} | go | {
"resource": ""
} |
q5940 | NewDiv | train | func NewDiv(Variable node.Node, Expression node.Node) *Div {
return &Div{
FreeFloating: nil,
Variable: Variable,
Expression: Expression,
}
} | go | {
"resource": ""
} |
q5941 | NewBitwiseOr | train | func NewBitwiseOr(Variable node.Node, Expression node.Node) *BitwiseOr {
return &BitwiseOr{
FreeFloating: nil,
Left: Variable,
Right: Expression,
}
} | go | {
"resource": ""
} |
q5942 | NewSpaceship | train | func NewSpaceship(Variable node.Node, Expression node.Node) *Spaceship {
return &Spaceship{
FreeFloating: nil,
Left: Variable,
Right: Expression,
}
} | go | {
"resource": ""
} |
q5943 | NewShortList | train | func NewShortList(Items []node.Node) *ShortList {
return &ShortList{
FreeFloating: nil,
Items: Items,
}
} | go | {
"resource": ""
} |
q5944 | NewThrow | train | func NewThrow(Expr node.Node) *Throw {
return &Throw{
FreeFloating: nil,
Expr: Expr,
}
} | go | {
"resource": ""
} |
q5945 | NewClassImplements | train | func NewClassImplements(interfaceNames []node.Node) *ClassImplements {
return &ClassImplements{
FreeFloating: nil,
InterfaceNames: interfaceNames,
}
} | go | {
"resource": ""
} |
q5946 | NewProperty | train | func NewProperty(Variable node.Node, Expr node.Node, PhpDocComment string) *Property {
return &Property{
FreeFloating: nil,
PhpDocComment: PhpDocComment,
Variable: Variable,
Expr: Expr,
}
} | go | {
"resource": ""
} |
q5947 | NewGreater | train | func NewGreater(Variable node.Node, Expression node.Node) *Greater {
return &Greater{
FreeFloating: nil,
Left: Variable,
Right: Expression,
}
} | go | {
"resource": ""
} |
q5948 | NewNodeListPosition | train | func (b *PositionBuilder) NewNodeListPosition(list []node.Node) *position.Position {
return &position.Position{
StartLine: b.getListStartPos(list).startLine,
EndLine: b.getListEndPos(list).endLine,
StartPos: b.getListStartPos(list).startPos,
EndPos: b.getListEndPos(list).endPos,
}
} | go | {
"resource": ""
} |
q5949 | NewNodePosition | train | func (b *PositionBuilder) NewNodePosition(n node.Node) *position.Position {
return &position.Position{
StartLine: b.getNodeStartPos(n).startLine,
EndLine: b.getNodeEndPos(n).endLine,
StartPos: b.getNodeStartPos(n).startPos,
EndPos: b.getNodeEndPos(n).endPos,
}
} | go | {
"resource": ""
} |
q5950 | NewTokenPosition | train | func (b *PositionBuilder) NewTokenPosition(t *scanner.Token) *position.Position {
return &position.Position{
StartLine: t.StartLine,
EndLine: t.EndLine,
StartPos: t.StartPos,
EndPos: t.EndPos,
}
} | go | {
"resource": ""
} |
q5951 | NewTokensPosition | train | func (b *PositionBuilder) NewTokensPosition(startToken *scanner.Token, endToken *scanner.Token) *position.Position {
return &position.Position{
StartLine: startToken.StartLine,
EndLine: endToken.EndLine,
StartPos: startToken.StartPos,
EndPos: endToken.EndPos,
}
} | go | {
"resource": ""
} |
q5952 | NewTokenNodePosition | train | func (b *PositionBuilder) NewTokenNodePosition(t *scanner.Token, n node.Node) *position.Position {
return &position.Position{
StartLine: t.StartLine,
EndLine: b.getNodeEndPos(n).endLine,
StartPos: t.StartPos,
EndPos: b.getNodeEndPos(n).endPos,
}
} | go | {
"resource": ""
} |
q5953 | NewNodeTokenPosition | train | func (b *PositionBuilder) NewNodeTokenPosition(n node.Node, t *scanner.Token) *position.Position {
return &position.Position{
StartLine: b.getNodeStartPos(n).startLine,
EndLine: t.EndLine,
StartPos: b.getNodeStartPos(n).startPos,
EndPos: t.EndPos,
}
} | go | {
"resource": ""
} |
q5954 | NewNodesPosition | train | func (b *PositionBuilder) NewNodesPosition(startNode node.Node, endNode node.Node) *position.Position {
return &position.Position{
StartLine: b.getNodeStartPos(startNode).startLine,
EndLine: b.getNodeEndPos(endNode).endLine,
StartPos: b.getNodeStartPos(startNode).startPos,
EndPos: b.getNodeEndPos(endNode... | go | {
"resource": ""
} |
q5955 | NewNodeListTokenPosition | train | func (b *PositionBuilder) NewNodeListTokenPosition(list []node.Node, t *scanner.Token) *position.Position {
return &position.Position{
StartLine: b.getListStartPos(list).startLine,
EndLine: t.EndLine,
StartPos: b.getListStartPos(list).startPos,
EndPos: t.EndPos,
}
} | go | {
"resource": ""
} |
q5956 | NewTokenNodeListPosition | train | func (b *PositionBuilder) NewTokenNodeListPosition(t *scanner.Token, list []node.Node) *position.Position {
return &position.Position{
StartLine: t.StartLine,
EndLine: b.getListEndPos(list).endLine,
StartPos: t.StartPos,
EndPos: b.getListEndPos(list).endPos,
}
} | go | {
"resource": ""
} |
q5957 | NewNodeNodeListPosition | train | func (b *PositionBuilder) NewNodeNodeListPosition(n node.Node, list []node.Node) *position.Position {
return &position.Position{
StartLine: b.getNodeStartPos(n).startLine,
EndLine: b.getListEndPos(list).endLine,
StartPos: b.getNodeStartPos(n).startPos,
EndPos: b.getListEndPos(list).endPos,
}
} | go | {
"resource": ""
} |
q5958 | NewNodeListNodePosition | train | func (b *PositionBuilder) NewNodeListNodePosition(list []node.Node, n node.Node) *position.Position {
return &position.Position{
StartLine: b.getListStartPos(list).startLine,
EndLine: b.getNodeEndPos(n).endLine,
StartPos: b.getListStartPos(list).startPos,
EndPos: b.getNodeEndPos(n).endPos,
}
} | go | {
"resource": ""
} |
q5959 | NewOptionalListTokensPosition | train | func (b *PositionBuilder) NewOptionalListTokensPosition(list []node.Node, t *scanner.Token, endToken *scanner.Token) *position.Position {
if list == nil {
return &position.Position{
StartLine: t.StartLine,
EndLine: endToken.EndLine,
StartPos: t.StartPos,
EndPos: endToken.EndPos,
}
}
return &po... | go | {
"resource": ""
} |
q5960 | NewStaticVar | train | func NewStaticVar(Variable node.Node, Expr node.Node) *StaticVar {
return &StaticVar{
FreeFloating: nil,
Variable: Variable,
Expr: Expr,
}
} | go | {
"resource": ""
} |
q5961 | NewObject | train | func NewObject(Expr node.Node) *Object {
return &Object{
FreeFloating: nil,
Expr: Expr,
}
} | go | {
"resource": ""
} |
q5962 | NewPow | train | func NewPow(Variable node.Node, Expression node.Node) *Pow {
return &Pow{
FreeFloating: nil,
Variable: Variable,
Expression: Expression,
}
} | go | {
"resource": ""
} |
q5963 | NewTraitAdaptationList | train | func NewTraitAdaptationList(Adaptations []node.Node) *TraitAdaptationList {
return &TraitAdaptationList{
FreeFloating: nil,
Adaptations: Adaptations,
}
} | go | {
"resource": ""
} |
q5964 | NewShiftRight | train | func NewShiftRight(Variable node.Node, Expression node.Node) *ShiftRight {
return &ShiftRight{
FreeFloating: nil,
Left: Variable,
Right: Expression,
}
} | go | {
"resource": ""
} |
q5965 | NewAltElse | train | func NewAltElse(Stmt node.Node) *AltElse {
return &AltElse{
FreeFloating: nil,
Stmt: Stmt,
}
} | go | {
"resource": ""
} |
q5966 | NewNotIdentical | train | func NewNotIdentical(Variable node.Node, Expression node.Node) *NotIdentical {
return &NotIdentical{
FreeFloating: nil,
Left: Variable,
Right: Expression,
}
} | go | {
"resource": ""
} |
q5967 | NewInterfaceExtends | train | func NewInterfaceExtends(InterfaceNames []node.Node) *InterfaceExtends {
return &InterfaceExtends{
FreeFloating: nil,
InterfaceNames: InterfaceNames,
}
} | go | {
"resource": ""
} |
q5968 | NewString | train | func NewString(Expr node.Node) *String {
return &String{
FreeFloating: nil,
Expr: Expr,
}
} | go | {
"resource": ""
} |
q5969 | NewTry | train | func NewTry(Stmts []node.Node, Catches []node.Node, Finally node.Node) *Try {
return &Try{
FreeFloating: nil,
Stmts: Stmts,
Catches: Catches,
Finally: Finally,
}
} | go | {
"resource": ""
} |
q5970 | NewInclude | train | func NewInclude(Expression node.Node) *Include {
return &Include{
FreeFloating: nil,
Expr: Expression,
}
} | go | {
"resource": ""
} |
q5971 | NewError | train | func NewError(msg string, p *position.Position) *Error {
return &Error{
Msg: msg,
Pos: p,
}
} | go | {
"resource": ""
} |
q5972 | NewArrayItem | train | func NewArrayItem(Key node.Node, Val node.Node) *ArrayItem {
return &ArrayItem{
FreeFloating: nil,
Key: Key,
Val: Val,
}
} | go | {
"resource": ""
} |
q5973 | NewDefault | train | func NewDefault(Stmts []node.Node) *Default {
return &Default{
FreeFloating: nil,
Stmts: Stmts,
}
} | go | {
"resource": ""
} |
q5974 | NewConstFetch | train | func NewConstFetch(Constant node.Node) *ConstFetch {
return &ConstFetch{
FreeFloating: nil,
Constant: Constant,
}
} | go | {
"resource": ""
} |
q5975 | NewIsset | train | func NewIsset(Variables []node.Node) *Isset {
return &Isset{
FreeFloating: nil,
Variables: Variables,
}
} | go | {
"resource": ""
} |
q5976 | NewEncapsed | train | func NewEncapsed(Parts []node.Node) *Encapsed {
return &Encapsed{
FreeFloating: nil,
Parts: Parts,
}
} | go | {
"resource": ""
} |
q5977 | NewAltFor | train | func NewAltFor(Init []node.Node, Cond []node.Node, Loop []node.Node, Stmt node.Node) *AltFor {
return &AltFor{
FreeFloating: nil,
Init: Init,
Cond: Cond,
Loop: Loop,
Stmt: Stmt,
}
} | go | {
"resource": ""
} |
q5978 | NewPropertyList | train | func NewPropertyList(Modifiers []node.Node, Properties []node.Node) *PropertyList {
return &PropertyList{
FreeFloating: nil,
Modifiers: Modifiers,
Properties: Properties,
}
} | go | {
"resource": ""
} |
q5979 | NewYieldFrom | train | func NewYieldFrom(Expression node.Node) *YieldFrom {
return &YieldFrom{
FreeFloating: nil,
Expr: Expression,
}
} | go | {
"resource": ""
} |
q5980 | NewReturn | train | func NewReturn(Expr node.Node) *Return {
return &Return{
FreeFloating: nil,
Expr: Expr,
}
} | go | {
"resource": ""
} |
q5981 | NewTraitUse | train | func NewTraitUse(Traits []node.Node, InnerAdaptationList node.Node) *TraitUse {
return &TraitUse{
FreeFloating: nil,
Traits: Traits,
TraitAdaptationList: InnerAdaptationList,
}
} | go | {
"resource": ""
} |
q5982 | NewInterface | train | func NewInterface(InterfaceName node.Node, Extends *InterfaceExtends, Stmts []node.Node, PhpDocComment string) *Interface {
return &Interface{
FreeFloating: nil,
PhpDocComment: PhpDocComment,
InterfaceName: InterfaceName,
Extends: Extends,
Stmts: Stmts,
}
} | go | {
"resource": ""
} |
q5983 | NewClassConstFetch | train | func NewClassConstFetch(Class node.Node, ConstantName node.Node) *ClassConstFetch {
return &ClassConstFetch{
FreeFloating: nil,
Class: Class,
ConstantName: ConstantName,
}
} | go | {
"resource": ""
} |
q5984 | NewEcho | train | func NewEcho(Exprs []node.Node) *Echo {
return &Echo{
FreeFloating: nil,
Exprs: Exprs,
}
} | go | {
"resource": ""
} |
q5985 | NewUnaryMinus | train | func NewUnaryMinus(Expression node.Node) *UnaryMinus {
return &UnaryMinus{
FreeFloating: nil,
Expr: Expression,
}
} | go | {
"resource": ""
} |
q5986 | NewAssign | train | func NewAssign(Variable node.Node, Expression node.Node) *Assign {
return &Assign{
FreeFloating: nil,
Variable: Variable,
Expression: Expression,
}
} | go | {
"resource": ""
} |
q5987 | NewBitwiseNot | train | func NewBitwiseNot(Expression node.Node) *BitwiseNot {
return &BitwiseNot{
FreeFloating: nil,
Expr: Expression,
}
} | go | {
"resource": ""
} |
q5988 | NewCase | train | func NewCase(Cond node.Node, Stmts []node.Node) *Case {
return &Case{
FreeFloating: nil,
Cond: Cond,
Stmts: Stmts,
}
} | go | {
"resource": ""
} |
q5989 | NewWhile | train | func NewWhile(Cond node.Node, Stmt node.Node) *While {
return &While{
FreeFloating: nil,
Cond: Cond,
Stmt: Stmt,
}
} | go | {
"resource": ""
} |
q5990 | NewNew | train | func NewNew(Class node.Node, ArgumentList *node.ArgumentList) *New {
return &New{
FreeFloating: nil,
Class: Class,
ArgumentList: ArgumentList,
}
} | go | {
"resource": ""
} |
q5991 | NewClassExtends | train | func NewClassExtends(className node.Node) *ClassExtends {
return &ClassExtends{
FreeFloating: nil,
ClassName: className,
}
} | go | {
"resource": ""
} |
q5992 | NewRequireOnce | train | func NewRequireOnce(Expression node.Node) *RequireOnce {
return &RequireOnce{
FreeFloating: nil,
Expr: Expression,
}
} | go | {
"resource": ""
} |
q5993 | NewCatch | train | func NewCatch(Types []node.Node, Variable node.Node, Stmts []node.Node) *Catch {
return &Catch{
FreeFloating: nil,
Types: Types,
Variable: Variable,
Stmts: Stmts,
}
} | go | {
"resource": ""
} |
q5994 | NewHeredoc | train | func NewHeredoc(Label string, Parts []node.Node) *Heredoc {
return &Heredoc{
FreeFloating: nil,
Label: Label,
Parts: Parts,
}
} | go | {
"resource": ""
} |
q5995 | NewMethodCall | train | func NewMethodCall(Variable node.Node, Method node.Node, ArgumentList *node.ArgumentList) *MethodCall {
return &MethodCall{
FreeFloating: nil,
Variable: Variable,
Method: Method,
ArgumentList: ArgumentList,
}
} | go | {
"resource": ""
} |
q5996 | NewTraitMethodRef | train | func NewTraitMethodRef(Trait node.Node, Method node.Node) *TraitMethodRef {
return &TraitMethodRef{
FreeFloating: nil,
Trait: Trait,
Method: Method,
}
} | go | {
"resource": ""
} |
q5997 | NewSmallerOrEqual | train | func NewSmallerOrEqual(Variable node.Node, Expression node.Node) *SmallerOrEqual {
return &SmallerOrEqual{
FreeFloating: nil,
Left: Variable,
Right: Expression,
}
} | go | {
"resource": ""
} |
q5998 | NewPropertyFetch | train | func NewPropertyFetch(Variable node.Node, Property node.Node) *PropertyFetch {
return &PropertyFetch{
FreeFloating: nil,
Variable: Variable,
Property: Property,
}
} | go | {
"resource": ""
} |
q5999 | NewClosureUse | train | func NewClosureUse(Uses []node.Node) *ClosureUse {
return &ClosureUse{
FreeFloating: nil,
Uses: Uses,
}
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.