_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,
ArgumentList: ArgumentList,
Extends: Extends,
Implements: Implements,
Stmts: Stmts,
}
}
|
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,
ReturnType: ReturnType,
Stmts: Stmts,
}
}
|
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).endPos,
}
}
|
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 &position.Position{
StartLine: b.getListStartPos(list).startLine,
EndLine: endToken.EndLine,
StartPos: b.getListStartPos(list).startPos,
EndPos: endToken.EndPos,
}
}
|
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.