io.shiftleft.codepropertygraph.generated.NodeKeys Maven / Gradle / Ivy
The newest version!
package io.shiftleft.codepropertygraph.generated;
import gremlin.scala.Key;
public class NodeKeys {
/** */
public static final Key IS_STATIC = new Key<>("IS_STATIC");
/** */
public static final Key PARAMETER_INDEX = new Key<>("PARAMETER_INDEX");
/** */
public static final Key SCORE = new Key<>("SCORE");
/** */
public static final Key ANNOTATION_FULL_NAME = new Key<>("ANNOTATION_FULL_NAME");
/** */
public static final Key ANNOTATION_NAME = new Key<>("ANNOTATION_NAME");
/** */
public static final Key CATEGORY = new Key<>("CATEGORY");
/** */
public static final Key CLASS_NAME = new Key<>("CLASS_NAME");
/** */
public static final Key CWE_LINK = new Key<>("CWE_LINK");
/** */
public static final Key DESCRIPTION = new Key<>("DESCRIPTION");
/** */
public static final Key EVALUATION_TYPE = new Key<>("EVALUATION_TYPE");
/** */
public static final Key FILENAME = new Key<>("FILENAME");
/** */
public static final Key FINGERPRINT = new Key<>("FINGERPRINT");
/** */
public static final Key LINE_NO = new Key<>("LINE_NO");
/** */
public static final Key LINK = new Key<>("LINK");
/** */
public static final Key LITERALS_TO_SINK = new Key<>("LITERALS_TO_SINK");
/** */
public static final Key METHOD_NAME = new Key<>("METHOD_NAME");
/** */
public static final Key METHOD_SHORT_NAME = new Key<>("METHOD_SHORT_NAME");
/** */
public static final Key NODE_ID = new Key<>("NODE_ID");
/** */
public static final Key NODE_LABEL = new Key<>("NODE_LABEL");
/** */
public static final Key OWASP_LINK = new Key<>("OWASP_LINK");
/** */
public static final Key PACKAGE_NAME = new Key<>("PACKAGE_NAME");
/** */
public static final Key PARAMETER = new Key<>("PARAMETER");
/** */
public static final Key PATH = new Key<>("PATH");
/** */
public static final Key PATTERN = new Key<>("PATTERN");
/** */
public static final Key SINK_TYPE = new Key<>("SINK_TYPE");
/** */
public static final Key SOURCE_TYPE = new Key<>("SOURCE_TYPE");
/** */
public static final Key SPID = new Key<>("SPID");
/** */
public static final Key SYMBOL = new Key<>("SYMBOL");
/** */
public static final Key TITLE = new Key<>("TITLE");
/** */
public static final Key VAR_TYPE = new Key<>("VAR_TYPE");
/** */
public static final Key VULN_DESCR = new Key<>("VULN_DESCR");
/** A version, given as a string */
public static final Key VERSION = new Key<>("VERSION");
/** AST-children of CALL nodes have an argument index, that is used to match call-site arguments with callee parameters. Explicit parameters are numbered from 1 to N, while index 0 is reserved for implicit self / this parameter. CALLs without implicit parameter therefore have arguments starting with index 1. AST-children of BLOCK nodes may have an argument index as well; in this case, the last argument index determines the return-value of a BLOCK expression */
public static final Key ARGUMENT_INDEX = new Key<>("ARGUMENT_INDEX");
/** Binary type signature */
public static final Key BINARY_SIGNATURE = new Key<>("BINARY_SIGNATURE");
/** Column where the code ends */
public static final Key COLUMN_NUMBER_END = new Key<>("COLUMN_NUMBER_END");
/** Column where the code starts */
public static final Key COLUMN_NUMBER = new Key<>("COLUMN_NUMBER");
/** Content of CONFIG_FILE node */
public static final Key CONTENT = new Key<>("CONTENT");
/** Deprecated */
public static final Key METHOD_INST_FULL_NAME = new Key<>("METHOD_INST_FULL_NAME");
/** Evaluation strategy for function parameters and return values. One of the values in "evaluationStrategies" */
public static final Key EVALUATION_STRATEGY = new Key<>("EVALUATION_STRATEGY");
/** Full name of an element, e.g., the class name along, including its package (e.g. "io.shiftleft.dataflowenging.layers.dataflows.DataFlowRunner.run"). In theory, the FULL_NAME just needs to be unique and is used for linking references, so a consecutive integer would be valid. In practice, this should be human readable */
public static final Key FULL_NAME = new Key<>("FULL_NAME");
/** General ordering property, such that the children of each AST-node are typically numbered from 1, ..., N (this is not enforced). The ordering has no technical meaning, but is used for pretty printing and OUGHT TO reflect order in the source code */
public static final Key ORDER = new Key<>("ORDER");
/** Identifier which uniquely describes a CLOSURE_BINDING. This property is used to match captured LOCAL nodes with the corresponding CLOSURE_BINDING nodes */
public static final Key CLOSURE_BINDING_ID = new Key<>("CLOSURE_BINDING_ID");
/** Indicates that the construct (METHOD or TYPE_DECL) is external, that is, it is referenced but not defined in the code (applies both to insular parsing and to library functions where we have header files only) */
public static final Key IS_EXTERNAL = new Key<>("IS_EXTERNAL");
/** Indicates the modifier which is represented by a MODIFIER node. See modifierTypes */
public static final Key MODIFIER_TYPE = new Key<>("MODIFIER_TYPE");
/** Indicates whether a call was already resolved. If not set this means not yet resolved */
public static final Key RESOLVED = new Key<>("RESOLVED");
/** Line where the code ends */
public static final Key LINE_NUMBER_END = new Key<>("LINE_NUMBER_END");
/** Line where the code starts */
public static final Key LINE_NUMBER = new Key<>("LINE_NUMBER");
/** Marks that a method has at least one mapping defined from the policies */
public static final Key HAS_MAPPING = new Key<>("HAS_MAPPING");
/** Method signature. The format is defined by the language front-end, and the backend simply compares strings to resolve function overloading, i.e. match call-sites to METHODs. In theory, consecutive integers would be valid, but in practice this should be human readable */
public static final Key SIGNATURE = new Key<>("SIGNATURE");
/** Name of represented object, e.g., method name (e.g. "run") */
public static final Key NAME = new Key<>("NAME");
/** Tag value */
public static final Key VALUE = new Key<>("VALUE");
/** The FULL_NAME of a method. Used to link CALL and METHOD nodes. It is required to have exactly one METHOD node for each METHOD_FULL_NAME */
public static final Key METHOD_FULL_NAME = new Key<>("METHOD_FULL_NAME");
/** The FULL_NAME of a the AST parent of an entity */
public static final Key AST_PARENT_FULL_NAME = new Key<>("AST_PARENT_FULL_NAME");
/** The code snippet the node represents */
public static final Key CODE = new Key<>("CODE");
/** The depth first ordering number used to detect back edges in reducible CFGs */
public static final Key DEPTH_FIRST_ORDER = new Key<>("DEPTH_FIRST_ORDER");
/** The dispatch type of a call, which is either static or dynamic. See dispatchTypes */
public static final Key DISPATCH_TYPE = new Key<>("DISPATCH_TYPE");
/** The group ID for a dependency */
public static final Key DEPENDENCY_GROUP_ID = new Key<>("DEPENDENCY_GROUP_ID");
/** The original name of the (potentially mangled) captured variable */
public static final Key CLOSURE_ORIGINAL_NAME = new Key<>("CLOSURE_ORIGINAL_NAME");
/** The programming language this graph originates from */
public static final Key LANGUAGE = new Key<>("LANGUAGE");
/** The static type decl of a TYPE. This property is matched against the FULL_NAME of TYPE_DECL nodes. It is required to have exactly one TYPE_DECL for each different TYPE_DECL_FULL_NAME */
public static final Key TYPE_DECL_FULL_NAME = new Key<>("TYPE_DECL_FULL_NAME");
/** The static type of an entity. E.g. expressions, local, parameters etc. This property is matched against the FULL_NAME of TYPE nodes and thus it is required to have at least one TYPE node for each TYPE_FULL_NAME */
public static final Key TYPE_FULL_NAME = new Key<>("TYPE_FULL_NAME");
/** The static types a TYPE_DECL inherits from. This property is matched against the FULL_NAME of TYPE nodes and thus it is required to have at least one TYPE node for each TYPE_FULL_NAME */
public static final Key INHERITS_FROM_TYPE_FULL_NAME = new Key<>("INHERITS_FROM_TYPE_FULL_NAME");
/** The type of the AST parent. Since this is only used in some parts of the graph the list does not include all possible parents by intention. Possible parents: METHOD, TYPE_DECL, NAMESPACE_BLOCK */
public static final Key AST_PARENT_TYPE = new Key<>("AST_PARENT_TYPE");
/** Type full name of which a TYPE_DECL is an alias of */
public static final Key ALIAS_TYPE_FULL_NAME = new Key<>("ALIAS_TYPE_FULL_NAME");
/** Type hint for the dynamic type */
public static final Key DYNAMIC_TYPE_HINT_FULL_NAME = new Key<>("DYNAMIC_TYPE_HINT_FULL_NAME");
/** Type name emitted by parser, only present for logical type UNKNOWN */
public static final Key PARSER_TYPE_NAME = new Key<>("PARSER_TYPE_NAME");
/** A method annotation */
public static class ANNOTATION {
/** The code snippet the node represents */
public static final Key CODE = new Key<>("CODE");
/** Name of represented object, e.g., method name (e.g. "run") */
public static final Key NAME = new Key<>("NAME");
/** Full name of an element, e.g., the class name along, including its package (e.g. "io.shiftleft.dataflowenging.layers.dataflows.DataFlowRunner.run"). In theory, the FULL_NAME just needs to be unique and is used for linking references, so a consecutive integer would be valid. In practice, this should be human readable */
public static final Key FULL_NAME = new Key<>("FULL_NAME");
/** General ordering property, such that the children of each AST-node are typically numbered from 1, ..., N (this is not enforced). The ordering has no technical meaning, but is used for pretty printing and OUGHT TO reflect order in the source code */
public static final Key ORDER = new Key<>("ORDER");
}
/** A literal value assigned to an ANNOTATION_PARAMETER */
public static class ANNOTATION_LITERAL {
/** The code snippet the node represents */
public static final Key CODE = new Key<>("CODE");
/** Name of represented object, e.g., method name (e.g. "run") */
public static final Key NAME = new Key<>("NAME");
/** General ordering property, such that the children of each AST-node are typically numbered from 1, ..., N (this is not enforced). The ordering has no technical meaning, but is used for pretty printing and OUGHT TO reflect order in the source code */
public static final Key ORDER = new Key<>("ORDER");
/** Column where the code starts */
public static final Key COLUMN_NUMBER = new Key<>("COLUMN_NUMBER");
/** Line where the code starts */
public static final Key LINE_NUMBER = new Key<>("LINE_NUMBER");
}
/** Formal annotation parameter */
public static class ANNOTATION_PARAMETER {
/** The code snippet the node represents */
public static final Key CODE = new Key<>("CODE");
/** General ordering property, such that the children of each AST-node are typically numbered from 1, ..., N (this is not enforced). The ordering has no technical meaning, but is used for pretty printing and OUGHT TO reflect order in the source code */
public static final Key ORDER = new Key<>("ORDER");
}
/** Assignment of annotation argument to annotation parameter */
public static class ANNOTATION_PARAMETER_ASSIGN {
/** The code snippet the node represents */
public static final Key CODE = new Key<>("CODE");
/** General ordering property, such that the children of each AST-node are typically numbered from 1, ..., N (this is not enforced). The ordering has no technical meaning, but is used for pretty printing and OUGHT TO reflect order in the source code */
public static final Key ORDER = new Key<>("ORDER");
}
/** Initialization construct for arrays */
public static class ARRAY_INITIALIZER {
/** The code snippet the node represents */
public static final Key CODE = new Key<>("CODE");
/** Column where the code starts */
public static final Key COLUMN_NUMBER = new Key<>("COLUMN_NUMBER");
/** Line where the code starts */
public static final Key LINE_NUMBER = new Key<>("LINE_NUMBER");
/** General ordering property, such that the children of each AST-node are typically numbered from 1, ..., N (this is not enforced). The ordering has no technical meaning, but is used for pretty printing and OUGHT TO reflect order in the source code */
public static final Key ORDER = new Key<>("ORDER");
}
/** A binding of a METHOD into a TYPE_DECL */
public static class BINDING {
/** Name of represented object, e.g., method name (e.g. "run") */
public static final Key NAME = new Key<>("NAME");
/** Method signature. The format is defined by the language front-end, and the backend simply compares strings to resolve function overloading, i.e. match call-sites to METHODs. In theory, consecutive integers would be valid, but in practice this should be human readable */
public static final Key SIGNATURE = new Key<>("SIGNATURE");
}
/** A structuring block in the AST */
public static class BLOCK {
/** The code snippet the node represents */
public static final Key CODE = new Key<>("CODE");
/** General ordering property, such that the children of each AST-node are typically numbered from 1, ..., N (this is not enforced). The ordering has no technical meaning, but is used for pretty printing and OUGHT TO reflect order in the source code */
public static final Key ORDER = new Key<>("ORDER");
/** AST-children of CALL nodes have an argument index, that is used to match call-site arguments with callee parameters. Explicit parameters are numbered from 1 to N, while index 0 is reserved for implicit self / this parameter. CALLs without implicit parameter therefore have arguments starting with index 1. AST-children of BLOCK nodes may have an argument index as well; in this case, the last argument index determines the return-value of a BLOCK expression */
public static final Key ARGUMENT_INDEX = new Key<>("ARGUMENT_INDEX");
/** The static type of an entity. E.g. expressions, local, parameters etc. This property is matched against the FULL_NAME of TYPE nodes and thus it is required to have at least one TYPE node for each TYPE_FULL_NAME */
public static final Key TYPE_FULL_NAME = new Key<>("TYPE_FULL_NAME");
/** Type hint for the dynamic type */
public static final Key DYNAMIC_TYPE_HINT_FULL_NAME = new Key<>("DYNAMIC_TYPE_HINT_FULL_NAME");
/** Line where the code starts */
public static final Key LINE_NUMBER = new Key<>("LINE_NUMBER");
/** Column where the code starts */
public static final Key COLUMN_NUMBER = new Key<>("COLUMN_NUMBER");
/** The depth first ordering number used to detect back edges in reducible CFGs */
public static final Key DEPTH_FIRST_ORDER = new Key<>("DEPTH_FIRST_ORDER");
}
/** A (method)-call */
public static class CALL {
/** The code snippet the node represents */
public static final Key CODE = new Key<>("CODE");
/** Name of represented object, e.g., method name (e.g. "run") */
public static final Key NAME = new Key<>("NAME");
/** General ordering property, such that the children of each AST-node are typically numbered from 1, ..., N (this is not enforced). The ordering has no technical meaning, but is used for pretty printing and OUGHT TO reflect order in the source code */
public static final Key ORDER = new Key<>("ORDER");
/** Deprecated */
public static final Key METHOD_INST_FULL_NAME = new Key<>("METHOD_INST_FULL_NAME");
/** The FULL_NAME of a method. Used to link CALL and METHOD nodes. It is required to have exactly one METHOD node for each METHOD_FULL_NAME */
public static final Key METHOD_FULL_NAME = new Key<>("METHOD_FULL_NAME");
/** AST-children of CALL nodes have an argument index, that is used to match call-site arguments with callee parameters. Explicit parameters are numbered from 1 to N, while index 0 is reserved for implicit self / this parameter. CALLs without implicit parameter therefore have arguments starting with index 1. AST-children of BLOCK nodes may have an argument index as well; in this case, the last argument index determines the return-value of a BLOCK expression */
public static final Key ARGUMENT_INDEX = new Key<>("ARGUMENT_INDEX");
/** The dispatch type of a call, which is either static or dynamic. See dispatchTypes */
public static final Key DISPATCH_TYPE = new Key<>("DISPATCH_TYPE");
/** Method signature. The format is defined by the language front-end, and the backend simply compares strings to resolve function overloading, i.e. match call-sites to METHODs. In theory, consecutive integers would be valid, but in practice this should be human readable */
public static final Key SIGNATURE = new Key<>("SIGNATURE");
/** The static type of an entity. E.g. expressions, local, parameters etc. This property is matched against the FULL_NAME of TYPE nodes and thus it is required to have at least one TYPE node for each TYPE_FULL_NAME */
public static final Key TYPE_FULL_NAME = new Key<>("TYPE_FULL_NAME");
/** Type hint for the dynamic type */
public static final Key DYNAMIC_TYPE_HINT_FULL_NAME = new Key<>("DYNAMIC_TYPE_HINT_FULL_NAME");
/** Line where the code starts */
public static final Key LINE_NUMBER = new Key<>("LINE_NUMBER");
/** Column where the code starts */
public static final Key COLUMN_NUMBER = new Key<>("COLUMN_NUMBER");
/** Indicates whether a call was already resolved. If not set this means not yet resolved */
public static final Key RESOLVED = new Key<>("RESOLVED");
/** The depth first ordering number used to detect back edges in reducible CFGs */
public static final Key DEPTH_FIRST_ORDER = new Key<>("DEPTH_FIRST_ORDER");
}
/** */
public static class CALL_CHAIN {
}
/** */
public static class CALL_SITE {
}
/** Represents the binding of a LOCAL or METHOD_PARAMETER_IN into the closure of a method */
public static class CLOSURE_BINDING {
/** Identifier which uniquely describes a CLOSURE_BINDING. This property is used to match captured LOCAL nodes with the corresponding CLOSURE_BINDING nodes */
public static final Key CLOSURE_BINDING_ID = new Key<>("CLOSURE_BINDING_ID");
/** Evaluation strategy for function parameters and return values. One of the values in "evaluationStrategies" */
public static final Key EVALUATION_STRATEGY = new Key<>("EVALUATION_STRATEGY");
/** The original name of the (potentially mangled) captured variable */
public static final Key CLOSURE_ORIGINAL_NAME = new Key<>("CLOSURE_ORIGINAL_NAME");
}
/** A comment */
public static class COMMENT {
/** Line where the code starts */
public static final Key LINE_NUMBER = new Key<>("LINE_NUMBER");
/** The code snippet the node represents */
public static final Key CODE = new Key<>("CODE");
}
/** Configuration file contents. Might be in use by a framework */
public static class CONFIG_FILE {
/** Name of represented object, e.g., method name (e.g. "run") */
public static final Key NAME = new Key<>("NAME");
/** Content of CONFIG_FILE node */
public static final Key CONTENT = new Key<>("CONTENT");
}
/** A control structure such as if, while, or for */
public static class CONTROL_STRUCTURE {
/** The code snippet the node represents */
public static final Key CODE = new Key<>("CODE");
/** Column where the code starts */
public static final Key COLUMN_NUMBER = new Key<>("COLUMN_NUMBER");
/** Line where the code starts */
public static final Key LINE_NUMBER = new Key<>("LINE_NUMBER");
/** General ordering property, such that the children of each AST-node are typically numbered from 1, ..., N (this is not enforced). The ordering has no technical meaning, but is used for pretty printing and OUGHT TO reflect order in the source code */
public static final Key ORDER = new Key<>("ORDER");
/** Type name emitted by parser, only present for logical type UNKNOWN */
public static final Key PARSER_TYPE_NAME = new Key<>("PARSER_TYPE_NAME");
/** AST-children of CALL nodes have an argument index, that is used to match call-site arguments with callee parameters. Explicit parameters are numbered from 1 to N, while index 0 is reserved for implicit self / this parameter. CALLs without implicit parameter therefore have arguments starting with index 1. AST-children of BLOCK nodes may have an argument index as well; in this case, the last argument index determines the return-value of a BLOCK expression */
public static final Key ARGUMENT_INDEX = new Key<>("ARGUMENT_INDEX");
}
/** This node represents a dependency */
public static class DEPENDENCY {
/** A version, given as a string */
public static final Key VERSION = new Key<>("VERSION");
/** Name of represented object, e.g., method name (e.g. "run") */
public static final Key NAME = new Key<>("NAME");
/** The group ID for a dependency */
public static final Key DEPENDENCY_GROUP_ID = new Key<>("DEPENDENCY_GROUP_ID");
}
/** */
public static class DETACHED_TRACKING_POINT {
}
/** Attribute of a DOM node */
public static class DOM_ATTRIBUTE {
/** Name of represented object, e.g., method name (e.g. "run") */
public static final Key NAME = new Key<>("NAME");
/** Tag value */
public static final Key VALUE = new Key<>("VALUE");
}
/** A node in a Document Object Model (Tree) as obtained from, e.g., an HTML parser */
public static class DOM_NODE {
/** Name of represented object, e.g., method name (e.g. "run") */
public static final Key NAME = new Key<>("NAME");
}
/** Node representing a source file. Often also the AST root */
public static class FILE {
/** Name of represented object, e.g., method name (e.g. "run") */
public static final Key NAME = new Key<>("NAME");
/** General ordering property, such that the children of each AST-node are typically numbered from 1, ..., N (this is not enforced). The ordering has no technical meaning, but is used for pretty printing and OUGHT TO reflect order in the source code */
public static final Key ORDER = new Key<>("ORDER");
}
/** */
public static class FINDING {
/** Name of represented object, e.g., method name (e.g. "run") */
public static final Key NAME = new Key<>("NAME");
/** */
public static final Key CATEGORY = new Key<>("CATEGORY");
/** */
public static final Key TITLE = new Key<>("TITLE");
/** */
public static final Key DESCRIPTION = new Key<>("DESCRIPTION");
/** */
public static final Key SCORE = new Key<>("SCORE");
/** */
public static final Key LINK = new Key<>("LINK");
/** */
public static final Key VULN_DESCR = new Key<>("VULN_DESCR");
/** */
public static final Key PARAMETER = new Key<>("PARAMETER");
/** */
public static final Key METHOD_NAME = new Key<>("METHOD_NAME");
/** */
public static final Key LINE_NO = new Key<>("LINE_NO");
/** */
public static final Key FILENAME = new Key<>("FILENAME");
/** */
public static final Key OWASP_LINK = new Key<>("OWASP_LINK");
/** */
public static final Key CWE_LINK = new Key<>("CWE_LINK");
}
/** */
public static class FLOW {
}
/** Indicates the usage of a framework. E.g. java spring. The name key is one of the values from frameworks list */
public static class FRAMEWORK {
/** Name of represented object, e.g., method name (e.g. "run") */
public static final Key NAME = new Key<>("NAME");
}
/** Data used by a framework */
public static class FRAMEWORK_DATA {
/** Name of represented object, e.g., method name (e.g. "run") */
public static final Key NAME = new Key<>("NAME");
/** Content of CONFIG_FILE node */
public static final Key CONTENT = new Key<>("CONTENT");
}
/** An arbitrary identifier/reference */
public static class IDENTIFIER {
/** The code snippet the node represents */
public static final Key CODE = new Key<>("CODE");
/** Name of represented object, e.g., method name (e.g. "run") */
public static final Key NAME = new Key<>("NAME");
/** General ordering property, such that the children of each AST-node are typically numbered from 1, ..., N (this is not enforced). The ordering has no technical meaning, but is used for pretty printing and OUGHT TO reflect order in the source code */
public static final Key ORDER = new Key<>("ORDER");
/** AST-children of CALL nodes have an argument index, that is used to match call-site arguments with callee parameters. Explicit parameters are numbered from 1 to N, while index 0 is reserved for implicit self / this parameter. CALLs without implicit parameter therefore have arguments starting with index 1. AST-children of BLOCK nodes may have an argument index as well; in this case, the last argument index determines the return-value of a BLOCK expression */
public static final Key ARGUMENT_INDEX = new Key<>("ARGUMENT_INDEX");
/** The static type of an entity. E.g. expressions, local, parameters etc. This property is matched against the FULL_NAME of TYPE nodes and thus it is required to have at least one TYPE node for each TYPE_FULL_NAME */
public static final Key TYPE_FULL_NAME = new Key<>("TYPE_FULL_NAME");
/** Type hint for the dynamic type */
public static final Key DYNAMIC_TYPE_HINT_FULL_NAME = new Key<>("DYNAMIC_TYPE_HINT_FULL_NAME");
/** Line where the code starts */
public static final Key LINE_NUMBER = new Key<>("LINE_NUMBER");
/** Column where the code starts */
public static final Key COLUMN_NUMBER = new Key<>("COLUMN_NUMBER");
/** The depth first ordering number used to detect back edges in reducible CFGs */
public static final Key DEPTH_FIRST_ORDER = new Key<>("DEPTH_FIRST_ORDER");
}
/** An implicit call site hidden in a method indicated by METHOD_MAP policy entries */
public static class IMPLICIT_CALL {
/** The code snippet the node represents */
public static final Key CODE = new Key<>("CODE");
/** Name of represented object, e.g., method name (e.g. "run") */
public static final Key NAME = new Key<>("NAME");
/** Method signature. The format is defined by the language front-end, and the backend simply compares strings to resolve function overloading, i.e. match call-sites to METHODs. In theory, consecutive integers would be valid, but in practice this should be human readable */
public static final Key SIGNATURE = new Key<>("SIGNATURE");
/** Line where the code starts */
public static final Key LINE_NUMBER = new Key<>("LINE_NUMBER");
/** Column where the code starts */
public static final Key COLUMN_NUMBER = new Key<>("COLUMN_NUMBER");
/** General ordering property, such that the children of each AST-node are typically numbered from 1, ..., N (this is not enforced). The ordering has no technical meaning, but is used for pretty printing and OUGHT TO reflect order in the source code */
public static final Key ORDER = new Key<>("ORDER");
}
/** */
public static class IOFLOW {
/** */
public static final Key FINGERPRINT = new Key<>("FINGERPRINT");
/** */
public static final Key LITERALS_TO_SINK = new Key<>("LITERALS_TO_SINK");
}
/** Literal/Constant */
public static class LITERAL {
/** The code snippet the node represents */
public static final Key CODE = new Key<>("CODE");
/** General ordering property, such that the children of each AST-node are typically numbered from 1, ..., N (this is not enforced). The ordering has no technical meaning, but is used for pretty printing and OUGHT TO reflect order in the source code */
public static final Key ORDER = new Key<>("ORDER");
/** AST-children of CALL nodes have an argument index, that is used to match call-site arguments with callee parameters. Explicit parameters are numbered from 1 to N, while index 0 is reserved for implicit self / this parameter. CALLs without implicit parameter therefore have arguments starting with index 1. AST-children of BLOCK nodes may have an argument index as well; in this case, the last argument index determines the return-value of a BLOCK expression */
public static final Key ARGUMENT_INDEX = new Key<>("ARGUMENT_INDEX");
/** The static type of an entity. E.g. expressions, local, parameters etc. This property is matched against the FULL_NAME of TYPE nodes and thus it is required to have at least one TYPE node for each TYPE_FULL_NAME */
public static final Key TYPE_FULL_NAME = new Key<>("TYPE_FULL_NAME");
/** Type hint for the dynamic type */
public static final Key DYNAMIC_TYPE_HINT_FULL_NAME = new Key<>("DYNAMIC_TYPE_HINT_FULL_NAME");
/** Line where the code starts */
public static final Key LINE_NUMBER = new Key<>("LINE_NUMBER");
/** Column where the code starts */
public static final Key COLUMN_NUMBER = new Key<>("COLUMN_NUMBER");
/** The depth first ordering number used to detect back edges in reducible CFGs */
public static final Key DEPTH_FIRST_ORDER = new Key<>("DEPTH_FIRST_ORDER");
}
/** A local variable */
public static class LOCAL {
/** The code snippet the node represents */
public static final Key CODE = new Key<>("CODE");
/** Name of represented object, e.g., method name (e.g. "run") */
public static final Key NAME = new Key<>("NAME");
/** Identifier which uniquely describes a CLOSURE_BINDING. This property is used to match captured LOCAL nodes with the corresponding CLOSURE_BINDING nodes */
public static final Key CLOSURE_BINDING_ID = new Key<>("CLOSURE_BINDING_ID");
/** The static type of an entity. E.g. expressions, local, parameters etc. This property is matched against the FULL_NAME of TYPE nodes and thus it is required to have at least one TYPE node for each TYPE_FULL_NAME */
public static final Key TYPE_FULL_NAME = new Key<>("TYPE_FULL_NAME");
/** Type hint for the dynamic type */
public static final Key DYNAMIC_TYPE_HINT_FULL_NAME = new Key<>("DYNAMIC_TYPE_HINT_FULL_NAME");
/** Line where the code starts */
public static final Key LINE_NUMBER = new Key<>("LINE_NUMBER");
/** Column where the code starts */
public static final Key COLUMN_NUMBER = new Key<>("COLUMN_NUMBER");
/** General ordering property, such that the children of each AST-node are typically numbered from 1, ..., N (this is not enforced). The ordering has no technical meaning, but is used for pretty printing and OUGHT TO reflect order in the source code */
public static final Key ORDER = new Key<>("ORDER");
}
/** */
public static class LOCATION {
/** */
public static final Key SYMBOL = new Key<>("SYMBOL");
/** The FULL_NAME of a method. Used to link CALL and METHOD nodes. It is required to have exactly one METHOD node for each METHOD_FULL_NAME */
public static final Key METHOD_FULL_NAME = new Key<>("METHOD_FULL_NAME");
/** */
public static final Key METHOD_SHORT_NAME = new Key<>("METHOD_SHORT_NAME");
/** */
public static final Key PACKAGE_NAME = new Key<>("PACKAGE_NAME");
/** Line where the code starts */
public static final Key LINE_NUMBER = new Key<>("LINE_NUMBER");
/** */
public static final Key CLASS_NAME = new Key<>("CLASS_NAME");
/** */
public static final Key NODE_LABEL = new Key<>("NODE_LABEL");
/** */
public static final Key FILENAME = new Key<>("FILENAME");
}
/** */
public static class MATCH_INFO {
/** */
public static final Key PATTERN = new Key<>("PATTERN");
/** */
public static final Key CATEGORY = new Key<>("CATEGORY");
}
/** Member of a class struct or union */
public static class MEMBER {
/** The code snippet the node represents */
public static final Key CODE = new Key<>("CODE");
/** Name of represented object, e.g., method name (e.g. "run") */
public static final Key NAME = new Key<>("NAME");
/** The static type of an entity. E.g. expressions, local, parameters etc. This property is matched against the FULL_NAME of TYPE nodes and thus it is required to have at least one TYPE node for each TYPE_FULL_NAME */
public static final Key TYPE_FULL_NAME = new Key<>("TYPE_FULL_NAME");
/** Type hint for the dynamic type */
public static final Key DYNAMIC_TYPE_HINT_FULL_NAME = new Key<>("DYNAMIC_TYPE_HINT_FULL_NAME");
/** General ordering property, such that the children of each AST-node are typically numbered from 1, ..., N (this is not enforced). The ordering has no technical meaning, but is used for pretty printing and OUGHT TO reflect order in the source code */
public static final Key ORDER = new Key<>("ORDER");
}
/** Node to save meta data about the graph on its properties. Exactly one node of this type per graph */
public static class META_DATA {
/** The programming language this graph originates from */
public static final Key LANGUAGE = new Key<>("LANGUAGE");
/** A version, given as a string */
public static final Key VERSION = new Key<>("VERSION");
/** */
public static final Key SPID = new Key<>("SPID");
}
/** A method/function/procedure */
public static class METHOD {
/** Name of represented object, e.g., method name (e.g. "run") */
public static final Key NAME = new Key<>("NAME");
/** Full name of an element, e.g., the class name along, including its package (e.g. "io.shiftleft.dataflowenging.layers.dataflows.DataFlowRunner.run"). In theory, the FULL_NAME just needs to be unique and is used for linking references, so a consecutive integer would be valid. In practice, this should be human readable */
public static final Key FULL_NAME = new Key<>("FULL_NAME");
/** Indicates that the construct (METHOD or TYPE_DECL) is external, that is, it is referenced but not defined in the code (applies both to insular parsing and to library functions where we have header files only) */
public static final Key IS_EXTERNAL = new Key<>("IS_EXTERNAL");
/** Method signature. The format is defined by the language front-end, and the backend simply compares strings to resolve function overloading, i.e. match call-sites to METHODs. In theory, consecutive integers would be valid, but in practice this should be human readable */
public static final Key SIGNATURE = new Key<>("SIGNATURE");
/** The type of the AST parent. Since this is only used in some parts of the graph the list does not include all possible parents by intention. Possible parents: METHOD, TYPE_DECL, NAMESPACE_BLOCK */
public static final Key AST_PARENT_TYPE = new Key<>("AST_PARENT_TYPE");
/** The FULL_NAME of a the AST parent of an entity */
public static final Key AST_PARENT_FULL_NAME = new Key<>("AST_PARENT_FULL_NAME");
/** Line where the code starts */
public static final Key LINE_NUMBER = new Key<>("LINE_NUMBER");
/** Column where the code starts */
public static final Key COLUMN_NUMBER = new Key<>("COLUMN_NUMBER");
/** Line where the code ends */
public static final Key LINE_NUMBER_END = new Key<>("LINE_NUMBER_END");
/** Column where the code ends */
public static final Key COLUMN_NUMBER_END = new Key<>("COLUMN_NUMBER_END");
/** General ordering property, such that the children of each AST-node are typically numbered from 1, ..., N (this is not enforced). The ordering has no technical meaning, but is used for pretty printing and OUGHT TO reflect order in the source code */
public static final Key ORDER = new Key<>("ORDER");
/** Marks that a method has at least one mapping defined from the policies */
public static final Key HAS_MAPPING = new Key<>("HAS_MAPPING");
/** The depth first ordering number used to detect back edges in reducible CFGs */
public static final Key DEPTH_FIRST_ORDER = new Key<>("DEPTH_FIRST_ORDER");
/** Binary type signature */
public static final Key BINARY_SIGNATURE = new Key<>("BINARY_SIGNATURE");
}
/** A method instance which always has to reference a method and may have type argument children if the referred to method is a template */
public static class METHOD_INST {
/** Name of represented object, e.g., method name (e.g. "run") */
public static final Key NAME = new Key<>("NAME");
/** Method signature. The format is defined by the language front-end, and the backend simply compares strings to resolve function overloading, i.e. match call-sites to METHODs. In theory, consecutive integers would be valid, but in practice this should be human readable */
public static final Key SIGNATURE = new Key<>("SIGNATURE");
/** Full name of an element, e.g., the class name along, including its package (e.g. "io.shiftleft.dataflowenging.layers.dataflows.DataFlowRunner.run"). In theory, the FULL_NAME just needs to be unique and is used for linking references, so a consecutive integer would be valid. In practice, this should be human readable */
public static final Key FULL_NAME = new Key<>("FULL_NAME");
/** The FULL_NAME of a method. Used to link CALL and METHOD nodes. It is required to have exactly one METHOD node for each METHOD_FULL_NAME */
public static final Key METHOD_FULL_NAME = new Key<>("METHOD_FULL_NAME");
/** General ordering property, such that the children of each AST-node are typically numbered from 1, ..., N (this is not enforced). The ordering has no technical meaning, but is used for pretty printing and OUGHT TO reflect order in the source code */
public static final Key ORDER = new Key<>("ORDER");
}
/** This node represents a formal parameter going towards the callee side */
public static class METHOD_PARAMETER_IN {
/** The code snippet the node represents */
public static final Key CODE = new Key<>("CODE");
/** General ordering property, such that the children of each AST-node are typically numbered from 1, ..., N (this is not enforced). The ordering has no technical meaning, but is used for pretty printing and OUGHT TO reflect order in the source code */
public static final Key ORDER = new Key<>("ORDER");
/** Name of represented object, e.g., method name (e.g. "run") */
public static final Key NAME = new Key<>("NAME");
/** Evaluation strategy for function parameters and return values. One of the values in "evaluationStrategies" */
public static final Key EVALUATION_STRATEGY = new Key<>("EVALUATION_STRATEGY");
/** The static type of an entity. E.g. expressions, local, parameters etc. This property is matched against the FULL_NAME of TYPE nodes and thus it is required to have at least one TYPE node for each TYPE_FULL_NAME */
public static final Key TYPE_FULL_NAME = new Key<>("TYPE_FULL_NAME");
/** Type hint for the dynamic type */
public static final Key DYNAMIC_TYPE_HINT_FULL_NAME = new Key<>("DYNAMIC_TYPE_HINT_FULL_NAME");
/** Line where the code starts */
public static final Key LINE_NUMBER = new Key<>("LINE_NUMBER");
/** Column where the code starts */
public static final Key COLUMN_NUMBER = new Key<>("COLUMN_NUMBER");
}
/** This node represents a formal parameter going towards the caller side */
public static class METHOD_PARAMETER_OUT {
/** The code snippet the node represents */
public static final Key CODE = new Key<>("CODE");
/** General ordering property, such that the children of each AST-node are typically numbered from 1, ..., N (this is not enforced). The ordering has no technical meaning, but is used for pretty printing and OUGHT TO reflect order in the source code */
public static final Key ORDER = new Key<>("ORDER");
/** Name of represented object, e.g., method name (e.g. "run") */
public static final Key NAME = new Key<>("NAME");
/** Evaluation strategy for function parameters and return values. One of the values in "evaluationStrategies" */
public static final Key EVALUATION_STRATEGY = new Key<>("EVALUATION_STRATEGY");
/** The static type of an entity. E.g. expressions, local, parameters etc. This property is matched against the FULL_NAME of TYPE nodes and thus it is required to have at least one TYPE node for each TYPE_FULL_NAME */
public static final Key TYPE_FULL_NAME = new Key<>("TYPE_FULL_NAME");
/** Line where the code starts */
public static final Key LINE_NUMBER = new Key<>("LINE_NUMBER");
/** Column where the code starts */
public static final Key COLUMN_NUMBER = new Key<>("COLUMN_NUMBER");
}
/** Reference to a method instance */
public static class METHOD_REF {
/** The code snippet the node represents */
public static final Key CODE = new Key<>("CODE");
/** General ordering property, such that the children of each AST-node are typically numbered from 1, ..., N (this is not enforced). The ordering has no technical meaning, but is used for pretty printing and OUGHT TO reflect order in the source code */
public static final Key ORDER = new Key<>("ORDER");
/** AST-children of CALL nodes have an argument index, that is used to match call-site arguments with callee parameters. Explicit parameters are numbered from 1 to N, while index 0 is reserved for implicit self / this parameter. CALLs without implicit parameter therefore have arguments starting with index 1. AST-children of BLOCK nodes may have an argument index as well; in this case, the last argument index determines the return-value of a BLOCK expression */
public static final Key ARGUMENT_INDEX = new Key<>("ARGUMENT_INDEX");
/** Deprecated */
public static final Key METHOD_INST_FULL_NAME = new Key<>("METHOD_INST_FULL_NAME");
/** The FULL_NAME of a method. Used to link CALL and METHOD nodes. It is required to have exactly one METHOD node for each METHOD_FULL_NAME */
public static final Key METHOD_FULL_NAME = new Key<>("METHOD_FULL_NAME");
/** Line where the code starts */
public static final Key LINE_NUMBER = new Key<>("LINE_NUMBER");
/** Column where the code starts */
public static final Key COLUMN_NUMBER = new Key<>("COLUMN_NUMBER");
/** The depth first ordering number used to detect back edges in reducible CFGs */
public static final Key DEPTH_FIRST_ORDER = new Key<>("DEPTH_FIRST_ORDER");
}
/** A formal method return */
public static class METHOD_RETURN {
/** The code snippet the node represents */
public static final Key CODE = new Key<>("CODE");
/** Evaluation strategy for function parameters and return values. One of the values in "evaluationStrategies" */
public static final Key EVALUATION_STRATEGY = new Key<>("EVALUATION_STRATEGY");
/** The static type of an entity. E.g. expressions, local, parameters etc. This property is matched against the FULL_NAME of TYPE nodes and thus it is required to have at least one TYPE node for each TYPE_FULL_NAME */
public static final Key TYPE_FULL_NAME = new Key<>("TYPE_FULL_NAME");
/** Type hint for the dynamic type */
public static final Key DYNAMIC_TYPE_HINT_FULL_NAME = new Key<>("DYNAMIC_TYPE_HINT_FULL_NAME");
/** Line where the code starts */
public static final Key LINE_NUMBER = new Key<>("LINE_NUMBER");
/** Column where the code starts */
public static final Key COLUMN_NUMBER = new Key<>("COLUMN_NUMBER");
/** General ordering property, such that the children of each AST-node are typically numbered from 1, ..., N (this is not enforced). The ordering has no technical meaning, but is used for pretty printing and OUGHT TO reflect order in the source code */
public static final Key ORDER = new Key<>("ORDER");
/** The depth first ordering number used to detect back edges in reducible CFGs */
public static final Key DEPTH_FIRST_ORDER = new Key<>("DEPTH_FIRST_ORDER");
}
/** */
public static class METHOD_SUMMARY {
/** */
public static final Key IS_STATIC = new Key<>("IS_STATIC");
/** Indicates that the construct (METHOD or TYPE_DECL) is external, that is, it is referenced but not defined in the code (applies both to insular parsing and to library functions where we have header files only) */
public static final Key IS_EXTERNAL = new Key<>("IS_EXTERNAL");
/** Binary type signature */
public static final Key BINARY_SIGNATURE = new Key<>("BINARY_SIGNATURE");
}
/** A modifier, e.g., static, public, private */
public static class MODIFIER {
/** Indicates the modifier which is represented by a MODIFIER node. See modifierTypes */
public static final Key MODIFIER_TYPE = new Key<>("MODIFIER_TYPE");
/** General ordering property, such that the children of each AST-node are typically numbered from 1, ..., N (this is not enforced). The ordering has no technical meaning, but is used for pretty printing and OUGHT TO reflect order in the source code */
public static final Key ORDER = new Key<>("ORDER");
}
/** This node represents a namespace as a whole whereas the NAMESPACE_BLOCK is used for each grouping occurrence of a namespace in code. Single representing NAMESPACE node is required for easier navigation in the query language */
public static class NAMESPACE {
/** Name of represented object, e.g., method name (e.g. "run") */
public static final Key