package dbscheme import ( "go/ast" "go/token" gotypes "go/types" "golang.org/x/tools/go/packages" ) var defaultSnippet = AddDefaultSnippet(` /** Duplicate code **/ duplicateCode( unique int id : @duplication, varchar(900) relativePath : string ref, int equivClass : int ref); similarCode( unique int id : @similarity, varchar(900) relativePath : string ref, int equivClass : int ref); @duplication_or_similarity = @duplication | @similarity; tokens( int id : @duplication_or_similarity ref, int offset : int ref, int beginLine : int ref, int beginColumn : int ref, int endLine : int ref, int endColumn : int ref); /** External data **/ externalData( int id : @externalDataElement, varchar(900) path : string ref, int column: int ref, varchar(900) value : string ref ); snapshotDate(unique date snapshotDate : date ref); sourceLocationPrefix(varchar(900) prefix : string ref); `) // Copied directly from the XML dbscheme var xmlSnippet = AddDefaultSnippet(` /* * XML Files */ xmlEncoding( unique int id: @file ref, string encoding: string ref ); xmlDTDs( unique int id: @xmldtd, string root: string ref, string publicId: string ref, string systemId: string ref, int fileid: @file ref ); xmlElements( unique int id: @xmlelement, string name: string ref, int parentid: @xmlparent ref, int idx: int ref, int fileid: @file ref ); xmlAttrs( unique int id: @xmlattribute, int elementid: @xmlelement ref, string name: string ref, string value: string ref, int idx: int ref, int fileid: @file ref ); xmlNs( int id: @xmlnamespace, string prefixName: string ref, string URI: string ref, int fileid: @file ref ); xmlHasNs( int elementId: @xmlnamespaceable ref, int nsId: @xmlnamespace ref, int fileid: @file ref ); xmlComments( unique int id: @xmlcomment, string text: string ref, int parentid: @xmlparent ref, int fileid: @file ref ); xmlChars( unique int id: @xmlcharacters, string text: string ref, int parentid: @xmlparent ref, int idx: int ref, int isCDATA: int ref, int fileid: @file ref ); @xmlparent = @file | @xmlelement; @xmlnamespaceable = @xmlelement | @xmlattribute; xmllocations( int xmlElement: @xmllocatable ref, int location: @location_default ref ); @xmllocatable = @xmlcharacters | @xmlelement | @xmlcomment | @xmlattribute | @xmldtd | @file | @xmlnamespace; `) // Compiler diagnostic tables var CompilationType = NewPrimaryKeyType("@compilation") /** * An invocation of the compiler. Note that more than one file may be * compiled per invocation. For example, this command compiles three * source files: * * go build a.go b.go c.go * * The `id` simply identifies the invocation, while `cwd` is the working * directory from which the compiler was invoked. */ var CompilationsTable = NewTable("compilations", EntityColumn(CompilationType, "id").Key(), StringColumn("cwd"), ) /** * The arguments that were passed to the extractor for a compiler * invocation. If `id` is for the compiler invocation * * go build a.go b.go c.go * * then typically there will be rows for * * num | arg * --- | --- * 0 | *path to extractor* * 1 | `--` * 2 | a.go * 3 | b.go * 4 | c.go */ var CompilationArgsTable = NewTable("compilation_args", EntityColumn(CompilationType, "id"), IntColumn("num"), StringColumn("arg"), ).KeySet("id", "num") /** * The source files that are compiled by a compiler invocation. * If `id` is for the compiler invocation * * go build a.go b.go c.go * * then there will be rows for * * num | arg * --- | --- * 0 | a.go * 1 | b.go * 2 | c.go */ var CompilationCompilingFilesTable = NewTable("compilation_compiling_files", EntityColumn(CompilationType, "id"), IntColumn("num"), EntityColumn(FileType, "file"), ).KeySet("id", "num") type CompilationTypeKind int const ( FRONTEND_CPU_SECONDS = iota FRONTEND_ELAPSED_SECONDS EXTRACTOR_CPU_SECONDS EXTRACTOR_ELAPSED_SECONDS ) /** * The time taken by the extractor for a compiler invocation. * * For each file `num`, there will be rows for * * kind | seconds * ---- | --- * 1 | CPU seconds used by the extractor frontend * 2 | Elapsed seconds during the extractor frontend * 3 | CPU seconds used by the extractor backend * 4 | Elapsed seconds during the extractor backend */ var CompilationTimeTable = NewTable("compilation_time", EntityColumn(CompilationType, "id"), IntColumn("num"), IntColumn("kind"), FloatColumn("secs"), ).KeySet("id", "num", "kind") var DiagnosticType = NewPrimaryKeyType("@diagnostic") /** * An error or warning generated by the extractor. * The diagnostic message `diagnostic` was generated during compiler * invocation `compilation`, and is the `file_number_diagnostic_number`th * message generated while extracting the `file_number`th file of that * invocation. */ var DiagnosticForTable = NewTable("diagnostic_for", EntityColumn(DiagnosticType, "diagnostic").Unique(), EntityColumn(CompilationType, "compilation"), IntColumn("file_number"), IntColumn("file_number_diagnostic_number"), ) /** * If extraction was successful, then `cpu_seconds` and * `elapsed_seconds` are the CPU time and elapsed time (respectively) * that extraction took for compiler invocation `id`. */ var CompilationFinishedTable = NewTable("compilation_finished", EntityColumn(CompilationType, "id").Unique(), FloatColumn("cpu_seconds"), FloatColumn("elapsed_seconds"), ) var DiagnosticsTable = NewTable("diagnostics", EntityColumn(DiagnosticType, "id").Key(), IntColumn("severity"), StringColumn("error_tag"), StringColumn("error_message"), StringColumn("full_error_message"), EntityColumn(LocationType, "location"), ) // ContainerType is the type of files and folders var ContainerType = NewUnionType("@container") // LocatableType is the type of program entities that have locations var LocatableType = NewUnionType("@locatable") // Adds xmllocatable as a locatable var XmlLocatableAsLocatable = LocatableType.AddChild("@xmllocatable") // NodeType is the type of AST nodes var NodeType = NewUnionType("@node", LocatableType) // DocumentableType is the type of AST nodes to which documentation can be attached var DocumentableType = NewUnionType("@documentable", NodeType) // ExprParentType is the type of AST nodes that can have expressions as children var ExprParentType = NewUnionType("@exprparent", NodeType) // ModExprParentType is the type of go.mod nodes that can have go.mod expressions as children var ModExprParentType = NewUnionType("@modexprparent", NodeType) // FieldParentType is the type of AST nodes that can have fields as children var FieldParentType = NewUnionType("@fieldparent", NodeType) // StmtParentType is the type of AST nodes that can have statements as children var StmtParentType = NewUnionType("@stmtparent", NodeType) // DeclParentType is the type of AST nodes that can have declarations as children var DeclParentType = NewUnionType("@declparent", NodeType) // TypeParamDeclParentType is the type of AST nodes that can have type parameter declarations as children var TypeParamDeclParentType = NewUnionType("@typeparamdeclparent", NodeType) // FuncDefType is the type of AST nodes that define functions, that is, function // declarations and function literals var FuncDefType = NewUnionType("@funcdef", StmtParentType, ExprParentType) // ScopeNodeType is the type of AST nodes that may have a scope attached to them var ScopeNodeType = NewUnionType("@scopenode", NodeType) // LocationDefaultType is the type of source locations var LocationDefaultType = NewPrimaryKeyType("@location_default") // FileType is the type of file AST nodes var FileType = NewPrimaryKeyType("@file", ContainerType, DocumentableType, ExprParentType, ModExprParentType, DeclParentType, ScopeNodeType) // FolderType is the type of folders var FolderType = NewPrimaryKeyType("@folder", ContainerType) // CommentGroupType is the type of comment groups var CommentGroupType = NewPrimaryKeyType("@comment_group", NodeType) // CommentType is the type of comments var CommentType = NewPrimaryKeyType("@comment", NodeType) // ExprType is the type of expression AST nodes var ExprType = NewPrimaryKeyType("@expr", ExprParentType) // FieldType is the type of field AST nodes var FieldType = NewPrimaryKeyType("@field", DocumentableType, ExprParentType) // StmtType is the type of statement AST nodes var StmtType = NewPrimaryKeyType("@stmt", ExprParentType, StmtParentType) // DeclType is the type of declaration AST nodes var DeclType = NewPrimaryKeyType("@decl", ExprParentType, StmtParentType, FieldParentType) // TypeParamDeclType is the type of type parameter declaration AST nodes var TypeParamDeclType = NewPrimaryKeyType("@typeparamdecl", DocumentableType, ExprParentType) // SpecType is the type of spec AST nodes var SpecType = NewPrimaryKeyType("@spec", ExprParentType, DocumentableType) // TypeType is the type of types var TypeType = NewPrimaryKeyType("@type") // LocationType is an alias for LocationDefaultType var LocationType = NewAliasType("@location", LocationDefaultType) // SourceLineType is an alias for LocatableType var SourceLineType = NewAliasType("@sourceline", LocatableType) // CommentKind is a case type for distinguishing different kinds of comments var CommentKind = NewCaseType(CommentType, "kind") // SlashSlashComment is the type of single-line comments starting with a double slash var SlashSlashComment = CommentKind.NewBranch("@slashslashcomment") // SlashStarComment is the type of block comments delimited by stars and slashes var SlashStarComment = CommentKind.NewBranch("@slashstarcomment") // ExprKind is a case type for distinguishing different kinds of expression AST nodes var ExprKind = NewCaseType(ExprType, "kind") // BadExpr is type of bad (that is, unparseable) expression AST nodes var BadExpr = ExprKind.NewBranch("@badexpr") // IdentExpr is the type of identifier expression AST nodes var IdentExpr = ExprKind.NewBranch("@ident") // EllipsisExpr is the type of ellipsis expression AST nodes var EllipsisExpr = ExprKind.NewBranch("@ellipsis") // BasicLitExpr is the type of basic (that is, primitive) literal expression AST nodes var BasicLitExpr = NewUnionType("@basiclit") // IntLitExpr is a case type for dishinguishing different kinds of literal expression AST nodes var IntLitExpr = ExprKind.NewBranch("@intlit", BasicLitExpr) // FloatLitExpr is the type of floating-point literal expression AST nodes var FloatLitExpr = ExprKind.NewBranch("@floatlit", BasicLitExpr) // ImagLitExpr is the type of imaginary literal expression AST nodes var ImagLitExpr = ExprKind.NewBranch("@imaglit", BasicLitExpr) // CharLitExpr is the type of character literal expression AST nodes var CharLitExpr = ExprKind.NewBranch("@charlit", BasicLitExpr) // StringLitExpr is the type of string literal expression AST nodes var StringLitExpr = ExprKind.NewBranch("@stringlit", BasicLitExpr) // FuncLitExpr is the type of function literal expression AST nodes var FuncLitExpr = ExprKind.NewBranch("@funclit", FuncDefType) // CompositeLitExpr is the type of composite literal expression AST nodes var CompositeLitExpr = ExprKind.NewBranch("@compositelit") // ParenExpr is the type of parenthesis expression AST nodes var ParenExpr = ExprKind.NewBranch("@parenexpr") // SelectorExpr is the type of selector expression AST nodes var SelectorExpr = ExprKind.NewBranch("@selectorexpr") // IndexExpr is the type of AST nodes for index expressions and generic type // instantiation expressions with one type argument. Note that syntactically // unambiguous generic instantiations will be extracted as // `GenericTypeInstantiationExpr`. var IndexExpr = ExprKind.NewBranch("@indexexpr") // GenericFunctionInstantiationExpr is the type of AST nodes that represent an instantiation // of a generic type. These correspond to some index expression AST nodes and all index // list expression AST nodes. var GenericFunctionInstantiationExpr = ExprKind.NewBranch("@genericfunctioninstantiationexpr") // GenericTypeInstantiationExpr is the type of AST nodes that represent an instantiation // of a generic type. These correspond to some index expression AST nodes and all index // list expression AST nodes. Note some syntactically ambiguous instantations are // extracted as an `IndexExpr` to be disambiguated in QL later. var GenericTypeInstantiationExpr = ExprKind.NewBranch("@generictypeinstantiationexpr") // SliceExpr is the type of slice expression AST nodes var SliceExpr = ExprKind.NewBranch("@sliceexpr") // TypeAssertExpr is the type of type assertion expression AST nodes var TypeAssertExpr = ExprKind.NewBranch("@typeassertexpr") // CallOrConversionExpr is the type of call and conversion expression AST nodes // (which cannot be distinguished by purely syntactic criteria) var CallOrConversionExpr = ExprKind.NewBranch("@callorconversionexpr") // StarExpr is the type of star expression AST nodes var StarExpr = ExprKind.NewBranch("@starexpr") // OperatorExpr is the type of operator expression AST nodes var OperatorExpr = NewUnionType("@operatorexpr") // LogicalExpr is the type of logical operator expression AST nodes var LogicalExpr = NewUnionType("@logicalexpr", OperatorExpr) // ArithmeticExpr is the type of arithmetic operator expression AST nodes var ArithmeticExpr = NewUnionType("@arithmeticexpr", OperatorExpr) // BitwiseExpr is the type of bitwise operator expression AST nodes var BitwiseExpr = NewUnionType("@bitwiseexpr", OperatorExpr) // UnaryExpr is the type of unary operator expression AST nodes var UnaryExpr = NewUnionType("@unaryexpr", OperatorExpr) // LogicalUnaryExpr is the type of logical unary operator expression AST nodes var LogicalUnaryExpr = NewUnionType("@logicalunaryexpr", UnaryExpr, LogicalExpr) // BitwiseUnaryExpr is the type of bitwise unary operator expression AST nodes var BitwiseUnaryExpr = NewUnionType("@bitwiseunaryexpr", UnaryExpr, BitwiseExpr) // ArithmeticUnaryExpr is the type of arithmetic unary operator expression AST nodes var ArithmeticUnaryExpr = NewUnionType("@arithmeticunaryexpr", UnaryExpr, ArithmeticExpr) // BinaryExpr is the type of binary operator expression AST nodes var BinaryExpr = NewUnionType("@binaryexpr", OperatorExpr) // LogicalBinaryExpr is the type of logical binary operator expression AST nodes var LogicalBinaryExpr = NewUnionType("@logicalbinaryexpr", BinaryExpr, LogicalExpr) // BitwiseBinaryExpr is the type of bitwise binary operator expression AST nodes var BitwiseBinaryExpr = NewUnionType("@bitwisebinaryexpr", BinaryExpr, BitwiseExpr) // ArithmeticBinaryExpr is the type of arithmetic binary operator expression AST nodes var ArithmeticBinaryExpr = NewUnionType("@arithmeticbinaryexpr", BinaryExpr, ArithmeticExpr) // ShiftExpr is the type of shift operator expression AST nodes var ShiftExpr = NewUnionType("@shiftexpr", BitwiseBinaryExpr) // Comparison is the type of comparison operator expression AST nodes var Comparison = NewUnionType("@comparison", BinaryExpr) // EqualityTest is the type of equality operator expression AST nodes var EqualityTest = NewUnionType("@equalitytest", Comparison) // RelationalComparison is the type of relational operator expression AST nodes var RelationalComparison = NewUnionType("@relationalcomparison", Comparison) // KeyValueExpr is the type of key-value expression AST nodes var KeyValueExpr = ExprKind.NewBranch("@keyvalueexpr") // ArrayTypeExpr is the type of array type AST nodes var ArrayTypeExpr = ExprKind.NewBranch("@arraytypeexpr") // StructTypeExpr is the type of struct type AST nodes var StructTypeExpr = ExprKind.NewBranch("@structtypeexpr", FieldParentType) // FuncTypeExpr is the type of function type AST nodes var FuncTypeExpr = ExprKind.NewBranch("@functypeexpr", FieldParentType, ScopeNodeType) // InterfaceTypeExpr is the type of interface type AST nodes var InterfaceTypeExpr = ExprKind.NewBranch("@interfacetypeexpr", FieldParentType) // MapTypeExpr is the type of map type AST nodes var MapTypeExpr = ExprKind.NewBranch("@maptypeexpr") // TypeSetLiteralExpr is the type of type set literal type AST nodes var TypeSetLiteralExpr = ExprKind.NewBranch("@typesetliteralexpr") // ChanTypeExpr is the type of channel type AST nodes var ChanTypeExpr = NewUnionType("@chantypeexpr") // UnaryExprs is a map from unary operator tokens to the corresponding AST node type var UnaryExprs = map[token.Token]*BranchType{ token.ADD: ExprKind.NewBranch("@plusexpr", ArithmeticUnaryExpr), token.SUB: ExprKind.NewBranch("@minusexpr", ArithmeticUnaryExpr), token.NOT: ExprKind.NewBranch("@notexpr", LogicalUnaryExpr), token.XOR: ExprKind.NewBranch("@complementexpr", BitwiseUnaryExpr), token.MUL: ExprKind.NewBranch("@derefexpr", UnaryExpr), token.AND: ExprKind.NewBranch("@addressexpr", UnaryExpr), token.ARROW: ExprKind.NewBranch("@arrowexpr", UnaryExpr), } // BinaryExprs is a map from binary operator tokens to the corresponding AST node type var BinaryExprs = map[token.Token]*BranchType{ token.LOR: ExprKind.NewBranch("@lorexpr", LogicalBinaryExpr), token.LAND: ExprKind.NewBranch("@landexpr", LogicalBinaryExpr), token.EQL: ExprKind.NewBranch("@eqlexpr", EqualityTest), token.NEQ: ExprKind.NewBranch("@neqexpr", EqualityTest), token.LSS: ExprKind.NewBranch("@lssexpr", RelationalComparison), token.LEQ: ExprKind.NewBranch("@leqexpr", RelationalComparison), token.GTR: ExprKind.NewBranch("@gtrexpr", RelationalComparison), token.GEQ: ExprKind.NewBranch("@geqexpr", RelationalComparison), token.ADD: ExprKind.NewBranch("@addexpr", ArithmeticBinaryExpr), token.SUB: ExprKind.NewBranch("@subexpr", ArithmeticBinaryExpr), token.OR: ExprKind.NewBranch("@orexpr", BitwiseBinaryExpr), token.XOR: ExprKind.NewBranch("@xorexpr", BitwiseBinaryExpr), token.MUL: ExprKind.NewBranch("@mulexpr", ArithmeticBinaryExpr), token.QUO: ExprKind.NewBranch("@quoexpr", ArithmeticBinaryExpr), token.REM: ExprKind.NewBranch("@remexpr", ArithmeticBinaryExpr), token.SHL: ExprKind.NewBranch("@shlexpr", ShiftExpr), token.SHR: ExprKind.NewBranch("@shrexpr", ShiftExpr), token.AND: ExprKind.NewBranch("@andexpr", BitwiseBinaryExpr), token.AND_NOT: ExprKind.NewBranch("@andnotexpr", BitwiseBinaryExpr), } // ChanTypeExprs is a map from channel type expressions to the corresponding AST node type var ChanTypeExprs = map[ast.ChanDir]*BranchType{ ast.SEND: ExprKind.NewBranch("@sendchantypeexpr", ChanTypeExpr), ast.RECV: ExprKind.NewBranch("@recvchantypeexpr", ChanTypeExpr), ast.SEND | ast.RECV: ExprKind.NewBranch("@sendrcvchantypeexpr", ChanTypeExpr), } // ErrorExpr is an AST node type that is not used anywhere var ErrorExpr = ExprKind.NewBranch("@errorexpr") // StmtKind is a case type for distinguishing different kinds of statement AST nodes var StmtKind = NewCaseType(StmtType, "kind") // BadStmtType is the type of bad (that is, unparseable) statement AST nodes var BadStmtType = StmtKind.NewBranch("@badstmt") // DeclStmtType is the type of declaration statement AST nodes var DeclStmtType = StmtKind.NewBranch("@declstmt", DeclParentType) // EmptyStmtType is the type of empty statement AST nodes var EmptyStmtType = StmtKind.NewBranch("@emptystmt") // LabeledStmtType is the type of labeled statement AST nodes var LabeledStmtType = StmtKind.NewBranch("@labeledstmt") // ExprStmtType is the type of expressio statemement AST nodes var ExprStmtType = StmtKind.NewBranch("@exprstmt") // SendStmtType is the type of send statement AST nodes var SendStmtType = StmtKind.NewBranch("@sendstmt") // IncDecStmtType is the type of increment/decrement statement AST nodes var IncDecStmtType = NewUnionType("@incdecstmt") // IncStmtType is the type of increment statement AST nodes var IncStmtType = StmtKind.NewBranch("@incstmt", IncDecStmtType) // DecStmtType is the type of decrement statement AST nodes var DecStmtType = StmtKind.NewBranch("@decstmt", IncDecStmtType) // AssignmentType is the type of assignment statement AST nodes var AssignmentType = NewUnionType("@assignment") // SimpleAssignStmtType is the type of simple (i.e., non-compound) assignment statement AST nodes var SimpleAssignStmtType = NewUnionType("@simpleassignstmt", AssignmentType) // CompoundAssignStmtType is the type of compound assignment statement AST nodes var CompoundAssignStmtType = NewUnionType("@compoundassignstmt", AssignmentType) // GoStmtType is the type of go statement AST nodes var GoStmtType = StmtKind.NewBranch("@gostmt") // DeferStmtType is the type of defer statement AST nodes var DeferStmtType = StmtKind.NewBranch("@deferstmt") // ReturnStmtType is the type of return statement AST nodes var ReturnStmtType = StmtKind.NewBranch("@returnstmt") // BranchStmtType is the type of branch statement AST nodes var BranchStmtType = NewUnionType("@branchstmt") // BreakStmtType is the type of break statement AST nodes var BreakStmtType = StmtKind.NewBranch("@breakstmt", BranchStmtType) // ContinueStmtType is the type of continue statement AST nodes var ContinueStmtType = StmtKind.NewBranch("@continuestmt", BranchStmtType) // GotoStmtType is the type of goto statement AST nodes var GotoStmtType = StmtKind.NewBranch("@gotostmt", BranchStmtType) // FallthroughStmtType is the type of fallthrough statement AST nodes var FallthroughStmtType = StmtKind.NewBranch("@fallthroughstmt", BranchStmtType) // BlockStmtType is the type of block statement AST nodes var BlockStmtType = StmtKind.NewBranch("@blockstmt", ScopeNodeType) // IfStmtType is the type of if statement AST nodes var IfStmtType = StmtKind.NewBranch("@ifstmt", ScopeNodeType) // CaseClauseType is the type of case clause AST nodes var CaseClauseType = StmtKind.NewBranch("@caseclause", ScopeNodeType) // SwitchStmtType is the type of switch statement AST nodes, covering both expression switch and type switch var SwitchStmtType = NewUnionType("@switchstmt", ScopeNodeType) // ExprSwitchStmtType is the type of expression-switch statement AST nodes var ExprSwitchStmtType = StmtKind.NewBranch("@exprswitchstmt", SwitchStmtType) // TypeSwitchStmtType is the type of type-switch statement AST nodes var TypeSwitchStmtType = StmtKind.NewBranch("@typeswitchstmt", SwitchStmtType) // CommClauseType is the type of comm clause AST ndoes var CommClauseType = StmtKind.NewBranch("@commclause", ScopeNodeType) // SelectStmtType is the type of select statement AST nodes var SelectStmtType = StmtKind.NewBranch("@selectstmt") // LoopStmtType is the type of loop statement AST nodes (including for statements and range statements) var LoopStmtType = NewUnionType("@loopstmt", ScopeNodeType) // ForStmtType is the type of for statement AST nodes var ForStmtType = StmtKind.NewBranch("@forstmt", LoopStmtType) // RangeStmtType is the type of range statement AST nodes var RangeStmtType = StmtKind.NewBranch("@rangestmt", LoopStmtType) // AssignStmtTypes is a map from assignmnt operator tokens to corresponding AST node types var AssignStmtTypes = map[token.Token]*BranchType{ token.ASSIGN: StmtKind.NewBranch("@assignstmt", SimpleAssignStmtType), token.DEFINE: StmtKind.NewBranch("@definestmt", SimpleAssignStmtType), token.ADD_ASSIGN: StmtKind.NewBranch("@addassignstmt", CompoundAssignStmtType), token.SUB_ASSIGN: StmtKind.NewBranch("@subassignstmt", CompoundAssignStmtType), token.MUL_ASSIGN: StmtKind.NewBranch("@mulassignstmt", CompoundAssignStmtType), token.QUO_ASSIGN: StmtKind.NewBranch("@quoassignstmt", CompoundAssignStmtType), token.REM_ASSIGN: StmtKind.NewBranch("@remassignstmt", CompoundAssignStmtType), token.AND_ASSIGN: StmtKind.NewBranch("@andassignstmt", CompoundAssignStmtType), token.OR_ASSIGN: StmtKind.NewBranch("@orassignstmt", CompoundAssignStmtType), token.XOR_ASSIGN: StmtKind.NewBranch("@xorassignstmt", CompoundAssignStmtType), token.SHL_ASSIGN: StmtKind.NewBranch("@shlassignstmt", CompoundAssignStmtType), token.SHR_ASSIGN: StmtKind.NewBranch("@shrassignstmt", CompoundAssignStmtType), token.AND_NOT_ASSIGN: StmtKind.NewBranch("@andnotassignstmt", CompoundAssignStmtType), } // DeclKind is a case type for distinguishing different kinds of declaration AST nodes var DeclKind = NewCaseType(DeclType, "kind") // BadDeclType is the type of bad (that is, unparseable) declaration AST nodes var BadDeclType = DeclKind.NewBranch("@baddecl") // GenDeclType is the type of generic declaration AST nodes var GenDeclType = NewUnionType("@gendecl", DocumentableType) // ImportDeclType is the type of import declaration AST nodes var ImportDeclType = DeclKind.NewBranch("@importdecl", GenDeclType) // ConstDeclType is the type of constant declaration AST nodes var ConstDeclType = DeclKind.NewBranch("@constdecl", GenDeclType) // TypeDeclType is the type of type declaration AST nodes var TypeDeclType = DeclKind.NewBranch("@typedecl", GenDeclType) // VarDeclType is the type of variable declaration AST nodes var VarDeclType = DeclKind.NewBranch("@vardecl", GenDeclType) // FuncDeclType is the type of function declaration AST nodes var FuncDeclType = DeclKind.NewBranch("@funcdecl", DocumentableType, FuncDefType, TypeParamDeclParentType) // SpecKind is a case type for distinguishing different kinds of declaration specification nodes var SpecKind = NewCaseType(SpecType, "kind") // ImportSpecType is the type of import declaration specification nodes var ImportSpecType = SpecKind.NewBranch("@importspec") // ValueSpecType is the type of value declaration specification nodes var ValueSpecType = SpecKind.NewBranch("@valuespec") // TypeSpecType is the type of type declaration specification nodes var TypeSpecType = NewUnionType("@typespec", TypeParamDeclParentType) // TypeDefSpecType is the type of type declaration specification nodes corresponding to type definitions var TypeDefSpecType = SpecKind.NewBranch("@typedefspec", TypeSpecType) // AliasSpecType is the type of type declaration specification nodes corresponding to alias declarations var AliasSpecType = SpecKind.NewBranch("@aliasspec", TypeSpecType) // ObjectType is the type of objects (that is, declared entities) var ObjectType = NewPrimaryKeyType("@object") // ObjectKind is a case type for distinguishing different kinds of built-in and declared objects var ObjectKind = NewCaseType(ObjectType, "kind") // TypeParamParentObjectType is the type of objects that can have type parameters as children var TypeParamParentObjectType = NewUnionType("@typeparamparentobject") // DeclObjectType is the type of declared objects var DeclObjectType = NewUnionType("@declobject") // BuiltinObjectType is the type of built-in objects var BuiltinObjectType = NewUnionType("@builtinobject") // PkgObjectType is the type of imported packages var PkgObjectType = ObjectKind.NewBranch("@pkgobject") // TypeObjectType is the type of declared or built-in named types var TypeObjectType = NewUnionType("@typeobject") // DeclTypeObjectType is the type of declared named types var DeclTypeObjectType = ObjectKind.NewBranch("@decltypeobject", TypeObjectType, DeclObjectType, TypeParamParentObjectType) // BuiltinTypeObjectType is the type of built-in named types var BuiltinTypeObjectType = ObjectKind.NewBranch("@builtintypeobject", TypeObjectType, BuiltinObjectType) // ValueObjectType is the type of declared or built-in variables or constants var ValueObjectType = NewUnionType("@valueobject") // ConstObjectType is the type of declared or built-in constants var ConstObjectType = NewUnionType("@constobject", ValueObjectType) // DeclConstObjectType is the type of declared constants var DeclConstObjectType = ObjectKind.NewBranch("@declconstobject", ConstObjectType, DeclObjectType) // BuiltinConstObjectType is the type of built-in constants var BuiltinConstObjectType = ObjectKind.NewBranch("@builtinconstobject", ConstObjectType, BuiltinObjectType) // VarObjectType is the type of declared or built-in variables (the latter do not currently exist) var VarObjectType = NewUnionType("@varobject", ValueObjectType) // DeclVarObjectType is the type of declared variables including function parameters, results and struct fields var DeclVarObjectType = ObjectKind.NewBranch("@declvarobject", VarObjectType, DeclObjectType) // FunctionObjectType is the type of declared or built-in functions var FunctionObjectType = NewUnionType("@functionobject", ValueObjectType) // DeclFuncObjectType is the type of declared functions, including (abstract and concrete) methods var DeclFuncObjectType = ObjectKind.NewBranch("@declfunctionobject", FunctionObjectType, DeclObjectType, TypeParamParentObjectType) // BuiltinFuncObjectType is the type of built-in functions var BuiltinFuncObjectType = ObjectKind.NewBranch("@builtinfunctionobject", FunctionObjectType, BuiltinObjectType) // LabelObjectType is the type of statement labels var LabelObjectType = ObjectKind.NewBranch("@labelobject") // ScopeType is the type of scopes var ScopeType = NewPrimaryKeyType("@scope") // ScopeKind is a case type for distinguishing different kinds of scopes var ScopeKind = NewCaseType(ScopeType, "kind") // UniverseScopeType is the type of the universe scope var UniverseScopeType = ScopeKind.NewBranch("@universescope") // PackageScopeType is the type of package scopes var PackageScopeType = ScopeKind.NewBranch("@packagescope") // LocalScopeType is the type of local (that is, non-universe, non-package) scopes var LocalScopeType = ScopeKind.NewBranch("@localscope", LocatableType) // TypeKind is a case type for distinguishing different kinds of types var TypeKind = NewCaseType(TypeType, "kind") // BasicType is the union of all basic types var BasicType = NewUnionType("@basictype") // BoolType is the union of the normal and literal bool types var BoolType = NewUnionType("@booltype", BasicType) // NumericType is the union of numeric types var NumericType = NewUnionType("@numerictype", BasicType) // IntegerType is the union of integer types var IntegerType = NewUnionType("@integertype", NumericType) // SignedIntegerType is the union of signed integer types var SignedIntegerType = NewUnionType("@signedintegertype", IntegerType) // UnsignedIntegerType is the union of unsigned integer types var UnsignedIntegerType = NewUnionType("@unsignedintegertype", IntegerType) // FloatType is the union of floating-point types var FloatType = NewUnionType("@floattype", NumericType) // ComplexType is the union of complex types var ComplexType = NewUnionType("@complextype", NumericType) // StringType is the union of the normal and literal string types var StringType = NewUnionType("@stringtype", BasicType) // LiteralType is the union of literal types var LiteralType = NewUnionType("@literaltype", BasicType) // BasicTypes is a map from basic type kinds to the corresponding entity types var BasicTypes = map[gotypes.BasicKind]*BranchType{ gotypes.Invalid: TypeKind.NewBranch("@invalidtype", BasicType), gotypes.Bool: TypeKind.NewBranch("@boolexprtype", BoolType), gotypes.Int: TypeKind.NewBranch("@inttype", SignedIntegerType), gotypes.Int8: TypeKind.NewBranch("@int8type", SignedIntegerType), gotypes.Int16: TypeKind.NewBranch("@int16type", SignedIntegerType), gotypes.Int32: TypeKind.NewBranch("@int32type", SignedIntegerType), gotypes.Int64: TypeKind.NewBranch("@int64type", SignedIntegerType), gotypes.Uint: TypeKind.NewBranch("@uinttype", UnsignedIntegerType), gotypes.Uint8: TypeKind.NewBranch("@uint8type", UnsignedIntegerType), gotypes.Uint16: TypeKind.NewBranch("@uint16type", UnsignedIntegerType), gotypes.Uint32: TypeKind.NewBranch("@uint32type", UnsignedIntegerType), gotypes.Uint64: TypeKind.NewBranch("@uint64type", UnsignedIntegerType), gotypes.Uintptr: TypeKind.NewBranch("@uintptrtype", UnsignedIntegerType), gotypes.Float32: TypeKind.NewBranch("@float32type", FloatType), gotypes.Float64: TypeKind.NewBranch("@float64type", FloatType), gotypes.Complex64: TypeKind.NewBranch("@complex64type", ComplexType), gotypes.Complex128: TypeKind.NewBranch("@complex128type", ComplexType), gotypes.String: TypeKind.NewBranch("@stringexprtype", StringType), gotypes.UnsafePointer: TypeKind.NewBranch("@unsafepointertype", BasicType), gotypes.UntypedBool: TypeKind.NewBranch("@boolliteraltype", LiteralType, BoolType), gotypes.UntypedInt: TypeKind.NewBranch("@intliteraltype", LiteralType, SignedIntegerType), gotypes.UntypedRune: TypeKind.NewBranch("@runeliteraltype", LiteralType, SignedIntegerType), gotypes.UntypedFloat: TypeKind.NewBranch("@floatliteraltype", LiteralType, FloatType), gotypes.UntypedComplex: TypeKind.NewBranch("@complexliteraltype", LiteralType, ComplexType), gotypes.UntypedString: TypeKind.NewBranch("@stringliteraltype", LiteralType, StringType), gotypes.UntypedNil: TypeKind.NewBranch("@nilliteraltype", LiteralType), } // CompositeType is the type of all composite (that is, non-basic) types var CompositeType = NewUnionType("@compositetype") // TypeParamType is the type of type parameter types var TypeParamType = TypeKind.NewBranch("@typeparamtype", CompositeType) // ElementContainerType is the type of types that have elements, such as arrays // and channels var ElementContainerType = NewUnionType("@containertype", CompositeType) // ArrayType is the type of array types var ArrayType = TypeKind.NewBranch("@arraytype", ElementContainerType) // SliceType is the type of slice types var SliceType = TypeKind.NewBranch("@slicetype", ElementContainerType) // StructType is the type of struct types var StructType = TypeKind.NewBranch("@structtype", CompositeType) // PointerType is the type of pointer types var PointerType = TypeKind.NewBranch("@pointertype", CompositeType) // InterfaceType is the type of interface types var InterfaceType = TypeKind.NewBranch("@interfacetype", CompositeType) // TupleType is the type of tuple types var TupleType = TypeKind.NewBranch("@tupletype", CompositeType) // SignatureType is the type of signature types var SignatureType = TypeKind.NewBranch("@signaturetype", CompositeType) // MapType is the type of map types var MapType = TypeKind.NewBranch("@maptype", ElementContainerType) // ChanType is the type of channel types var ChanType = NewUnionType("@chantype", ElementContainerType) // ChanTypes is a map from channel type directions to the corresponding type var ChanTypes = map[gotypes.ChanDir]*BranchType{ gotypes.SendOnly: TypeKind.NewBranch("@sendchantype", ChanType), gotypes.RecvOnly: TypeKind.NewBranch("@recvchantype", ChanType), gotypes.SendRecv: TypeKind.NewBranch("@sendrcvchantype", ChanType), } // NamedType is the type of named types var NamedType = TypeKind.NewBranch("@namedtype", CompositeType) // TypeSetLiteral is the type of type set literals var TypeSetLiteral = TypeKind.NewBranch("@typesetliteraltype", CompositeType) // PackageType is the type of packages var PackageType = NewPrimaryKeyType("@package") // ModExprType is the type of go.mod expression nodes var ModExprType = NewPrimaryKeyType("@modexpr", ModExprParentType, DocumentableType) // ModExprKind is a case type for distinguishing different kinds of go.mod expression nodes var ModExprKind = NewCaseType(ModExprType, "kind") // ModCommentBlockType is the type of go.mod comment block AST nodes var ModCommentBlockType = ModExprKind.NewBranch("@modcommentblock") // ModLineType is the type of go.mod line AST nodes var ModLineType = ModExprKind.NewBranch("@modline") // ModLineBlockType is the type of go.mod line block AST nodes var ModLineBlockType = ModExprKind.NewBranch("@modlineblock") // ModLParenType is the type of go.mod line block start AST nodes var ModLParenType = ModExprKind.NewBranch("@modlparen") // ModRParenType is the type of go.mod line block end AST nodes var ModRParenType = ModExprKind.NewBranch("@modrparen") // ErrorType is the type of frontend errors var ErrorType = NewPrimaryKeyType("@error") // ErrorKind is a case type for distinguishing different kinds of frontend errors var ErrorKind = NewCaseType(ErrorType, "kind") // ErrorTypes is a map from error kinds to the corresponding type var ErrorTypes = map[packages.ErrorKind]*BranchType{ packages.UnknownError: ErrorKind.NewBranch("@unknownerror"), packages.ListError: ErrorKind.NewBranch("@listerror"), packages.ParseError: ErrorKind.NewBranch("@parseerror"), packages.TypeError: ErrorKind.NewBranch("@typeerror"), } // ErrorTypes is a map from error kinds to the corresponding tag var ErrorTags = map[packages.ErrorKind]string{ packages.UnknownError: "@unknownerror", packages.ListError: "@listerror", packages.ParseError: "@parseerror", packages.TypeError: "@typeerror", } // LocationsDefaultTable is the table defining location objects var LocationsDefaultTable = NewTable("locations_default", EntityColumn(LocationDefaultType, "id").Key(), EntityColumn(FileType, "file"), IntColumn("beginLine"), IntColumn("beginColumn"), IntColumn("endLine"), IntColumn("endColumn"), ) // NumlinesTable is the table containing LoC information var NumlinesTable = NewTable("numlines", EntityColumn(SourceLineType, "element_id"), IntColumn("num_lines"), IntColumn("num_code"), IntColumn("num_comment"), ) // FilesTable is the table defining file nodes var FilesTable = NewTable("files", EntityColumn(FileType, "id").Key(), StringColumn("name"), ) // FoldersTable is the table defining folder entities var FoldersTable = NewTable("folders", EntityColumn(FolderType, "id").Key(), StringColumn("name"), ) // ContainerParentTable is the table defining the parent-child relation among container entities var ContainerParentTable = NewTable("containerparent", EntityColumn(ContainerType, "parent"), EntityColumn(ContainerType, "child").Unique(), ) // HasLocationTable is the table associating entities with their locations var HasLocationTable = NewTable("has_location", EntityColumn(LocatableType, "locatable").Unique(), EntityColumn(LocationType, "location"), ) // CommentGroupsTable is the table defining comment group entities var CommentGroupsTable = NewTable("comment_groups", EntityColumn(CommentGroupType, "id").Key(), EntityColumn(FileType, "parent"), IntColumn("idx"), ).KeySet("parent", "idx") // CommentsTable is the table defining comment entities var CommentsTable = NewTable("comments", EntityColumn(CommentType, "id").Key(), IntColumn("kind"), EntityColumn(CommentGroupType, "parent"), IntColumn("idx"), StringColumn("text"), ) // DocCommentsTable is the table associating doc comments with the nodes they document var DocCommentsTable = NewTable("doc_comments", EntityColumn(DocumentableType, "node").Unique(), EntityColumn(CommentGroupType, "comment"), ) // ExprsTable is the table defining expression AST nodes var ExprsTable = NewTable("exprs", EntityColumn(ExprType, "id").Key(), IntColumn("kind"), EntityColumn(ExprParentType, "parent"), IntColumn("idx"), ).KeySet("parent", "idx") // LiteralsTable is the table associating literal expression AST nodes with their values var LiteralsTable = NewTable("literals", EntityColumn(ExprType, "expr").Unique(), StringColumn("value"), StringColumn("raw"), ) // ConstValuesTable is the table associating constant expressions with their values var ConstValuesTable = NewTable("constvalues", EntityColumn(ExprType, "expr").Unique(), StringColumn("value"), StringColumn("exact"), ) // FieldsTable is the table defining field AST nodes var FieldsTable = NewTable("fields", EntityColumn(FieldType, "id").Key(), EntityColumn(FieldParentType, "parent"), IntColumn("idx"), ) // TypeParamDeclsTable is the table defining type param declaration AST nodes var TypeParamDeclsTable = NewTable("typeparamdecls", EntityColumn(TypeParamDeclType, "id").Key(), EntityColumn(TypeParamDeclParentType, "parent"), IntColumn("idx"), ) // StmtsTable is the table defining statement AST nodes var StmtsTable = NewTable("stmts", EntityColumn(StmtType, "id").Key(), IntColumn("kind"), EntityColumn(StmtParentType, "parent"), IntColumn("idx"), ).KeySet("parent", "idx") // DeclsTable is the table defining declaration AST nodes var DeclsTable = NewTable("decls", EntityColumn(DeclType, "id").Key(), IntColumn("kind"), EntityColumn(DeclParentType, "parent"), IntColumn("idx"), ).KeySet("parent", "idx") // SpecsTable is the table defining declaration specification AST nodes var SpecsTable = NewTable("specs", EntityColumn(SpecType, "id").Key(), IntColumn("kind"), EntityColumn(GenDeclType, "parent"), IntColumn("idx"), ).KeySet("parent", "idx") // ScopesTable is the table defining scopes var ScopesTable = NewTable("scopes", EntityColumn(ScopeType, "id").Key(), IntColumn("kind"), ) // ScopeNestingTable is the table describing scope nesting var ScopeNestingTable = NewTable("scopenesting", EntityColumn(ScopeType, "inner").Unique(), EntityColumn(ScopeType, "outer"), ) // ScopeNodesTable is the table associating local scopes with the AST nodes that induce them var ScopeNodesTable = NewTable("scopenodes", EntityColumn(ScopeNodeType, "node").Unique(), EntityColumn(LocalScopeType, "scope"), ) // ObjectsTable is the table describing objects (that is, declared entities) var ObjectsTable = NewTable("objects", EntityColumn(ObjectType, "id").Key(), IntColumn("kind"), StringColumn("name"), ) // ObjectScopesTable is the table describing the scope to which an object belongs (if any) var ObjectScopesTable = NewTable("objectscopes", EntityColumn(ObjectType, "object").Unique(), EntityColumn(ScopeType, "scope"), ) // ObjectTypesTable is the table describing the type of an object (if any) var ObjectTypesTable = NewTable("objecttypes", EntityColumn(ObjectType, "object").Unique(), EntityColumn(TypeType, "tp"), ) // MethodReceiversTable maps methods to their receiver var MethodReceiversTable = NewTable("methodreceivers", EntityColumn(ObjectType, "method").Unique(), EntityColumn(ObjectType, "receiver"), ) // FieldStructsTable maps fields to the structs they are in var FieldStructsTable = NewTable("fieldstructs", EntityColumn(ObjectType, "field").Unique(), EntityColumn(StructType, "struct"), ) // MethodHostsTable maps interface methods to the named type they belong to var MethodHostsTable = NewTable("methodhosts", EntityColumn(ObjectType, "method"), EntityColumn(NamedType, "host"), ) // DefsTable maps identifiers to the objects they define var DefsTable = NewTable("defs", EntityColumn(IdentExpr, "ident"), EntityColumn(ObjectType, "object"), ) // UsesTable maps identifiers to the objects they denote var UsesTable = NewTable("uses", EntityColumn(IdentExpr, "ident"), EntityColumn(ObjectType, "object"), ) // TypesTable is the table describing types var TypesTable = NewTable("types", EntityColumn(TypeType, "id").Key(), IntColumn("kind"), ) // TypeOfTable is the table associating expressions with their types (if known) var TypeOfTable = NewTable("type_of", EntityColumn(ExprType, "expr").Unique(), EntityColumn(TypeType, "tp"), ) // TypeNameTable is the table associating named types with their names var TypeNameTable = NewTable("typename", EntityColumn(TypeType, "tp").Unique(), StringColumn("name"), ) // KeyTypeTable is the table associating maps with their key type var KeyTypeTable = NewTable("key_type", EntityColumn(MapType, "map").Unique(), EntityColumn(TypeType, "tp"), ) // ElementTypeTable is the table associating container types with their element // type var ElementTypeTable = NewTable("element_type", EntityColumn(ElementContainerType, "container").Unique(), EntityColumn(TypeType, "tp"), ) // BaseTypeTable is the table associating pointer types with their base type var BaseTypeTable = NewTable("base_type", EntityColumn(PointerType, "ptr").Unique(), EntityColumn(TypeType, "tp"), ) // UnderlyingTypeTable is the table associating named types with their // underlying type var UnderlyingTypeTable = NewTable("underlying_type", EntityColumn(NamedType, "named").Unique(), EntityColumn(TypeType, "tp"), ) // ComponentTypesTable is the table associating composite types with their component types var ComponentTypesTable = NewTable("component_types", EntityColumn(CompositeType, "parent"), IntColumn("index"), StringColumn("name"), EntityColumn(TypeType, "tp"), ).KeySet("parent", "index") // ArrayLengthTable is the table associating array types with their length (represented as a string // since Go array lengths are 64-bit and hence do not always fit into a QL integer) var ArrayLengthTable = NewTable("array_length", EntityColumn(ArrayType, "tp").Unique(), StringColumn("len"), ) // TypeObjectTable maps types to their corresponding objects, if any var TypeObjectTable = NewTable("type_objects", EntityColumn(TypeType, "tp").Unique(), EntityColumn(ObjectType, "object"), ) // PackagesTable is the table describing packages var PackagesTable = NewTable("packages", EntityColumn(PackageType, "id").Key(), StringColumn("name"), StringColumn("path"), EntityColumn(PackageScopeType, "scope"), ) // ModExprsTable is the table defining expression AST nodes for go.mod files var ModExprsTable = NewTable("modexprs", EntityColumn(ModExprType, "id").Key(), IntColumn("kind"), EntityColumn(ModExprParentType, "parent"), IntColumn("idx"), ).KeySet("parent", "idx") // ModTokensTable is the table associating go.mod tokens with their Line or LineBlock var ModTokensTable = NewTable("modtokens", StringColumn("token"), EntityColumn(ModExprType, "parent"), IntColumn("idx"), ).KeySet("parent", "idx") // ErrorsTable is the table describing frontend errors var ErrorsTable = NewTable("errors", EntityColumn(ErrorType, "id").Key(), IntColumn("kind"), StringColumn("msg"), StringColumn("rawpos"), StringColumn("file"), IntColumn("line"), IntColumn("col"), EntityColumn(PackageType, "package"), IntColumn("idx"), ).KeySet("package", "idx") // HasEllipsisTable is the table containing all call expressions that have ellipses var HasEllipsisTable = NewTable("has_ellipsis", EntityColumn(CallOrConversionExpr, "id"), ) // VariadicTable is the table describing which functions are variadic var VariadicTable = NewTable("variadic", EntityColumn(SignatureType, "id"), ) // TypeParamTable is the table describing type parameter types var TypeParamTable = NewTable("typeparam", EntityColumn(TypeParamType, "tp").Unique(), StringColumn("name"), EntityColumn(CompositeType, "bound"), EntityColumn(TypeParamParentObjectType, "parent"), IntColumn("idx"), ).KeySet("parent", "idx")