diff --git a/xpp/.gitignore b/xpp/.gitignore new file mode 100644 index 000000000000..fcd7d00c2708 --- /dev/null +++ b/xpp/.gitignore @@ -0,0 +1,4 @@ +extractor/**/bin/* +extractor/**/obj/* +ql/build/ +extractor-pack/ diff --git a/xpp/build-linux64.ps1 b/xpp/build-linux64.ps1 new file mode 100644 index 000000000000..03592ec0a8ac --- /dev/null +++ b/xpp/build-linux64.ps1 @@ -0,0 +1,25 @@ +param ( + [Parameter(Mandatory=$true)][string]$cliFolder +) + +# Mirrors the PowerShell extractor's build scripts: publish the extractor into the CLI's +# language folder, then copy the extractor configuration, dbscheme and tool scripts alongside. +# +# The X++ compiler package is proprietary and is not bundled. The extractor resolves it at run +# time from XPP_COMPILER_PACKAGE, which must be set wherever extraction happens. + +$toolsFolder = Join-Path (Join-Path (Join-Path $cliFolder "xpp") "tools") "linux64" +# Only the extractor is shipped. Xpp.SchemaGenerator is a build-time tool and comes in +# through the solution, so the project is published rather than the solution. +dotnet publish (Join-Path "$PSScriptRoot/extractor" "Xpp.Extractor" | Resolve-Path) -o $toolsFolder -r linux-x64 -c Release --self-contained +if ($LASTEXITCODE -ne 0) { + Write-Host "Build failed" + exit 1 +} + +$xppFolder = Join-Path -Path $cliFolder -ChildPath "xpp" +Copy-Item -Path "$PSScriptRoot/codeql-extractor.yml" -Destination $xppFolder -Force +$qlLibFolder = Join-Path -Path "$PSScriptRoot/ql" -ChildPath "lib" +Copy-Item -Path (Join-Path $qlLibFolder "xpp.dbscheme") -Destination $xppFolder -Force +Copy-Item -Path (Join-Path $qlLibFolder "xpp.dbscheme.stats") -Destination $xppFolder -Force +Copy-Item -Path "$PSScriptRoot/tools" -Destination $xppFolder -Recurse -Force diff --git a/xpp/build-osx64.ps1 b/xpp/build-osx64.ps1 new file mode 100644 index 000000000000..68de879c851a --- /dev/null +++ b/xpp/build-osx64.ps1 @@ -0,0 +1,25 @@ +param ( + [Parameter(Mandatory=$true)][string]$cliFolder +) + +# Mirrors the PowerShell extractor's build scripts: publish the extractor into the CLI's +# language folder, then copy the extractor configuration, dbscheme and tool scripts alongside. +# +# The X++ compiler package is proprietary and is not bundled. The extractor resolves it at run +# time from XPP_COMPILER_PACKAGE, which must be set wherever extraction happens. + +$toolsFolder = Join-Path (Join-Path (Join-Path $cliFolder "xpp") "tools") "osx64" +# Only the extractor is shipped. Xpp.SchemaGenerator is a build-time tool and comes in +# through the solution, so the project is published rather than the solution. +dotnet publish (Join-Path "$PSScriptRoot/extractor" "Xpp.Extractor" | Resolve-Path) -o $toolsFolder -r osx-x64 -c Release --self-contained +if ($LASTEXITCODE -ne 0) { + Write-Host "Build failed" + exit 1 +} + +$xppFolder = Join-Path -Path $cliFolder -ChildPath "xpp" +Copy-Item -Path "$PSScriptRoot/codeql-extractor.yml" -Destination $xppFolder -Force +$qlLibFolder = Join-Path -Path "$PSScriptRoot/ql" -ChildPath "lib" +Copy-Item -Path (Join-Path $qlLibFolder "xpp.dbscheme") -Destination $xppFolder -Force +Copy-Item -Path (Join-Path $qlLibFolder "xpp.dbscheme.stats") -Destination $xppFolder -Force +Copy-Item -Path "$PSScriptRoot/tools" -Destination $xppFolder -Recurse -Force diff --git a/xpp/build-win64.ps1 b/xpp/build-win64.ps1 new file mode 100644 index 000000000000..6d181be3ca1a --- /dev/null +++ b/xpp/build-win64.ps1 @@ -0,0 +1,25 @@ +param ( + [Parameter(Mandatory=$true)][string]$cliFolder +) + +# Mirrors the PowerShell extractor's build scripts: publish the extractor into the CLI's +# language folder, then copy the extractor configuration, dbscheme and tool scripts alongside. +# +# The X++ compiler package is proprietary and is not bundled. The extractor resolves it at run +# time from XPP_COMPILER_PACKAGE, which must be set wherever extraction happens. + +$toolsFolder = Join-Path (Join-Path (Join-Path $cliFolder "xpp") "tools") "win64" +# Only the extractor is shipped. Xpp.SchemaGenerator is a build-time tool and comes in +# through the solution, so the project is published rather than the solution. +dotnet publish (Join-Path "$PSScriptRoot/extractor" "Xpp.Extractor" | Resolve-Path) -o $toolsFolder -r win-x64 -c Release --self-contained +if ($LASTEXITCODE -ne 0) { + Write-Host "Build failed" + exit 1 +} + +$xppFolder = Join-Path -Path $cliFolder -ChildPath "xpp" +Copy-Item -Path "$PSScriptRoot/codeql-extractor.yml" -Destination $xppFolder -Force +$qlLibFolder = Join-Path -Path "$PSScriptRoot/ql" -ChildPath "lib" +Copy-Item -Path (Join-Path $qlLibFolder "xpp.dbscheme") -Destination $xppFolder -Force +Copy-Item -Path (Join-Path $qlLibFolder "xpp.dbscheme.stats") -Destination $xppFolder -Force +Copy-Item -Path "$PSScriptRoot/tools" -Destination $xppFolder -Recurse -Force diff --git a/xpp/codegen.conf b/xpp/codegen.conf new file mode 100644 index 000000000000..73326696c855 --- /dev/null +++ b/xpp/codegen.conf @@ -0,0 +1,10 @@ +# configuration file for X++ code generation default options +--schema=schema +--generate=dbscheme,ql +--dbscheme=ql/lib/xpp.dbscheme +--ql-output=ql/lib/codeql/xpp/elements/internal/generated +--ql-stub-output=ql/lib/codeql/xpp/elements +# codegen requires a test output directory, but its per-node-type placeholders are not worth +# committing; real tests live in ql/test/library-tests. This path is gitignored. +--ql-test-output=ql/build/extractor-tests +--script-name=xpp/tools/generate-schema.sh diff --git a/xpp/codeql-extractor.yml b/xpp/codeql-extractor.yml new file mode 100644 index 000000000000..9612f9a64a04 --- /dev/null +++ b/xpp/codeql-extractor.yml @@ -0,0 +1,12 @@ +name: "xpp" +display_name: "X++" +version: 0.0.1 +column_kind: "utf16" +legacy_qltest_extraction: true +build_modes: + - none +file_types: + - name: xpp + display_name: X++ metadata objects + extensions: + - .xml diff --git a/xpp/extractor/Xpp.Extraction/AstSequence.cs b/xpp/extractor/Xpp.Extraction/AstSequence.cs new file mode 100644 index 000000000000..f9e5f384de58 --- /dev/null +++ b/xpp/extractor/Xpp.Extraction/AstSequence.cs @@ -0,0 +1,68 @@ +using System.Collections; + +namespace Xpp.Extraction; + +/// +/// Flattens the collection shapes the X++ compiler uses for child nodes. +/// +public static class AstSequence +{ + /// + /// The elements of , with dictionary entries reduced to their values. + /// + /// + /// The compiler holds some children in dictionaries keyed by name, such as a class's fields + /// and methods. Iterating one as a bare yields + /// rather than the child, so the entries have to be + /// unwrapped or those subtrees are labelled wrongly and never traversed. + /// + public static IEnumerable Elements(object? value) + { + switch (value) + { + case null: + case string: + yield break; + + // Dictionary<,> and the compiler's LinkedDictionary<,> both implement the + // non-generic interface, which exposes the values directly. + case IDictionary dictionary: + foreach (var item in dictionary.Values) + { + if (item is not null) + yield return item; + } + + yield break; + + case IEnumerable sequence: + foreach (var item in sequence) + { + var unwrapped = Unwrap(item); + if (unwrapped is not null) + yield return unwrapped; + } + + yield break; + } + } + + /// + /// The value of a key/value entry, or the item itself when it is not one. + /// + /// + /// A dictionary typed only as IEnumerable<KeyValuePair<,>> does not reach + /// the case above, so entries are also unwrapped here. + /// + private static object? Unwrap(object? item) + { + if (item is null) + return null; + + var type = item.GetType(); + if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(KeyValuePair<,>)) + return type.GetProperty("Value")?.GetValue(item); + + return item; + } +} diff --git a/xpp/extractor/Xpp.Extraction/CompilerPackageResolver.cs b/xpp/extractor/Xpp.Extraction/CompilerPackageResolver.cs new file mode 100644 index 000000000000..0cac5431d766 --- /dev/null +++ b/xpp/extractor/Xpp.Extraction/CompilerPackageResolver.cs @@ -0,0 +1,57 @@ +using System.Reflection; +using System.Runtime.Loader; + +namespace Xpp.Extraction; + +/// +/// Resolves the X++ compiler assemblies from an extracted +/// Microsoft.Dynamics.AX.Platform.CompilerPackage at run time. +/// +/// +/// The package is proprietary, so it is neither committed nor copied into build output. The +/// extractor locates it through XPP_COMPILER_PACKAGE instead, which also keeps a single +/// copy shared between the extractor and any other tool that needs it. +/// +public static class CompilerPackageResolver +{ + public const string PackageVariable = "XPP_COMPILER_PACKAGE"; + + private static bool installed; + + /// + /// Starts resolving compiler assemblies from , or from + /// XPP_COMPILER_PACKAGE when it is null. + /// + /// + /// The package directory is unset or does not exist. + /// + public static void Install(string? packageDirectory = null) + { + if (installed) + return; + + packageDirectory ??= Environment.GetEnvironmentVariable(PackageVariable); + + if (string.IsNullOrEmpty(packageDirectory)) + { + throw new DirectoryNotFoundException( + $"{PackageVariable} is not set. Point it at an extracted " + + "Microsoft.Dynamics.AX.Platform.CompilerPackage."); + } + + if (!Directory.Exists(packageDirectory)) + { + throw new DirectoryNotFoundException( + $"{PackageVariable} does not exist: {packageDirectory}"); + } + + var root = packageDirectory; + AssemblyLoadContext.Default.Resolving += (context, name) => + { + var candidate = Path.Combine(root, name.Name + ".dll"); + return File.Exists(candidate) ? context.LoadFromAssemblyPath(candidate) : null; + }; + + installed = true; + } +} diff --git a/xpp/extractor/Xpp.Extraction/Extractor.cs b/xpp/extractor/Xpp.Extraction/Extractor.cs new file mode 100644 index 000000000000..609be9e9333b --- /dev/null +++ b/xpp/extractor/Xpp.Extraction/Extractor.cs @@ -0,0 +1,177 @@ +using System.Runtime.CompilerServices; +using System.Xml.Linq; +using Microsoft.Dynamics.AX.Framework.Xlnt.XppParser; +using XppComment = Microsoft.Dynamics.AX.Framework.Xlnt.XppParser.Comment; +using Microsoft.Dynamics.AX.Metadata.XppCompiler; +using Xpp.Extraction.Generated; + +namespace Xpp.Extraction; + +/// Outcome of extracting a single metadata object. +public sealed record ExtractionResult( + string Path, + int Blocks, + int Nodes, + int Unsupported, + IReadOnlyList Errors); + +/// +/// Parses the X++ in a metadata object and writes the resulting AST as TRAP. +/// +public sealed class Extractor +{ + /// + /// Method bodies parse without metadata; class and interface headers need a provider in + /// order to look up the type named by `extends`. + /// + private readonly IXppcMetadataProvider metadata = NullMetadataProvider.Create(); + + public ExtractionResult Extract(string path, ITrapFile trap) + { + var text = File.ReadAllText(path); + var errors = new List(); + + XDocument document; + try + { + document = XppSourceFile.Parse(text); + } + catch (Exception e) + { + return new ExtractionResult(path, 0, 0, 0, [$"malformed XML: {e.Message}"]); + } + + var name = XppSourceFile.ObjectName(document) ?? Path.GetFileNameWithoutExtension(path); + var elementType = ElementType(path); + + var fileLabel = trap.FreshLabel(); + trap.Tuple("files", fileLabel, path); + + var blocks = 0; + var nodes = 0; + var unsupported = 0; + + // Shared across blocks so a node reachable from two of them is only emitted once. + var seen = new HashSet(ReferenceEqualityComparer.Instance); + + foreach (var block in XppSourceFile.Blocks(document)) + { + blocks++; + var context = new ParserContext(elementType, name); + var diagnostics = new DiagnosticsHandler(); + var macros = new MacroLibrary(); + var lineOffset = block.LineOffset; + + Ast? unit; + try + { + // The declaration block holds the class or interface header; everything else is + // a method body. + unit = block.Name is null + ? Pass1.ParseClassOrInterface( + context, block.Source, metadata, diagnostics, macros, + ref lineOffset, 0, []) + : Pass1.ParseMethod( + context, block.Source, metadata, diagnostics, macros, ref lineOffset, 0); + } + catch (Exception e) + { + errors.Add($"{name}.{block.Name ?? ""}: {e.GetType().Name}: {e.Message}"); + continue; + } + + if (unit is null) + continue; + + EmitTree(trap, fileLabel, unit, seen, ref nodes, ref unsupported); + } + + return new ExtractionResult(path, blocks, nodes, unsupported, errors); + } + + /// + /// The parser's name for the kind of object being parsed, derived from the metadata + /// directory. The directories carry an `Ax` prefix that the parser does not accept. + /// + private static string ElementType(string path) + { + var directory = Path.GetFileName(Path.GetDirectoryName(path)) ?? "AxClass"; + return directory.StartsWith("Ax", StringComparison.Ordinal) + ? directory["Ax".Length..] + : directory; + } + + /// Walks the AST, writing each node's tuples exactly once. + /// + /// Children come back from the emitter rather than being re-read here. Some of the + /// compiler's node properties are structs, which box to a fresh object on every read, so + /// reading a property twice yields two objects and therefore two different labels: one for + /// the reference and one for the definition, leaving both dangling. + /// + private static void EmitTree( + ITrapFile trap, Label file, object root, HashSet seen, + ref int nodes, ref int unsupported) + { + var pending = new Stack(); + pending.Push(root); + + var children = new List(); + + while (pending.Count > 0) + { + var node = pending.Pop(); + if (!seen.Add(node)) + continue; + + nodes++; + var id = trap.Label(node); + children.Clear(); + + // Comments are referenced by CompilationUnit but are not Ast nodes, so the + // generated emitter does not know them. + if (node is XppComment comment) + { + trap.Tuple("comments", id); + if (comment.Text is { } text) + trap.Tuple("comment_texts", id, text); + } + else if (!AstTrapEmitter.Emit(trap, id, node, children)) + { + unsupported++; + } + + EmitLocation(trap, file, id, node); + + foreach (var child in children) + pending.Push(child); + } + } + + /// + /// Records where came from. + /// + /// + /// The parser was given the source block's line offset, so these positions are already + /// relative to the containing file rather than to the extracted fragment. + /// + private static void EmitLocation(ITrapFile trap, Label file, Label id, object node) + { + var position = node switch + { + Ast ast => ast.Position, + XppComment comment => comment.Position, + _ => null, + }; + + // Nodes the parser synthesises carry no extent, and TextPosition is a reference type so + // it can also be absent outright. Recording a zero span would put alerts at line 1. + if (position is null || position.StartLine <= 0) + return; + + var location = trap.FreshLabel(); + trap.Tuple( + "locations", location, file, + position.StartLine, position.StartCol, position.EndLine, position.EndCol); + trap.Tuple("locatable_locations", id, location); + } +} diff --git a/xpp/extractor/Xpp.Extraction/ExtractorLayout.cs b/xpp/extractor/Xpp.Extraction/ExtractorLayout.cs new file mode 100644 index 000000000000..2e8e4515b895 --- /dev/null +++ b/xpp/extractor/Xpp.Extraction/ExtractorLayout.cs @@ -0,0 +1,62 @@ +namespace Xpp.Extraction; + +/// +/// The environment CodeQL sets up for an extractor run. +/// +/// +/// The CLI passes the TRAP and source-archive destinations through +/// CODEQL_EXTRACTOR_XPP_* variables rather than on the command line. +/// +public sealed record ExtractorLayout( + string? TrapDirectory, + string? SourceArchiveDirectory, + string? SourceRoot) +{ + public static ExtractorLayout FromEnvironment() => + new( + Environment.GetEnvironmentVariable("CODEQL_EXTRACTOR_XPP_TRAP_DIR"), + Environment.GetEnvironmentVariable("CODEQL_EXTRACTOR_XPP_SOURCE_ARCHIVE_DIR"), + Environment.GetEnvironmentVariable("CODEQL_EXTRACTOR_XPP_WIP_DATABASE") is not null + ? Directory.GetCurrentDirectory() + : null); + + /// + /// Where the TRAP for should be written, or null when the + /// caller wants TRAP on standard output instead. + /// + public string? TrapPathFor(string sourcePath) + { + if (TrapDirectory is null) + return null; + + return Path.Combine(TrapDirectory, Relative(sourcePath) + ".trap"); + } + + /// Where should be copied for the source archive. + public string? ArchivePathFor(string sourcePath) + { + if (SourceArchiveDirectory is null) + return null; + + return Path.Combine(SourceArchiveDirectory, Relative(sourcePath)); + } + + /// + /// A path safe to append to a destination directory: rooted paths are flattened by dropping + /// the root, matching how the CLI lays out both trees. + /// + private string Relative(string sourcePath) + { + var full = Path.GetFullPath(sourcePath); + + if (SourceRoot is not null) + { + var relative = Path.GetRelativePath(SourceRoot, full); + if (!relative.StartsWith("..", StringComparison.Ordinal)) + return relative; + } + + return full.TrimStart(Path.DirectorySeparatorChar, '/') + .Replace(':', '_'); + } +} diff --git a/xpp/extractor/Xpp.Extraction/Generated/AstTrapEmitter.g.cs b/xpp/extractor/Xpp.Extraction/Generated/AstTrapEmitter.g.cs new file mode 100644 index 000000000000..fb372c981ec6 --- /dev/null +++ b/xpp/extractor/Xpp.Extraction/Generated/AstTrapEmitter.g.cs @@ -0,0 +1,2939 @@ +// Generated by xpp/extractor/Xpp.SchemaGenerator, do not edit by hand. +// +// Relation names are validated against xpp/ql/lib/xpp.dbscheme at generation time. +// Regenerate with `xpp/tools/generate-schema.sh`. + +using System.Runtime.CompilerServices; +using Xpp.Extraction; + +namespace Xpp.Extraction.Generated; + +internal static class AstTrapEmitter +{ + + /// + /// Labels a child and records it, so the caller walks the same instances that were + /// labelled here. Reading a property twice is not safe: some are structs, which box + /// to a new object on each read and would otherwise get two different labels. + /// + private static Label Child(ITrapFile trap, ICollection children, object node) + { + children.Add(node); + return trap.Label(node); + } + + private static void EmitOwnArraySpecification(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.ArraySpecification)node; + if (n.Index1 is { } c_index1) + trap.Tuple("array_specification_index1s", id, Child(trap, children, c_index1)); + if (n.Index2 is { } c_index2) + trap.Tuple("array_specification_index2s", id, Child(trap, children, c_index2)); + } + + private static void EmitOwnAssignMultipleFieldStatement(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.AssignMultipleFieldStatement)node; + if (n.Expression is { } c_expression) + trap.Tuple("assign_multiple_field_statement_expressions", id, Child(trap, children, c_expression)); + { + var i = 0; + foreach (var item in AstSequence.Elements(n.Fields)) + { + trap.Tuple("assign_multiple_field_statement_fields", id, i, Child(trap, children, item)); + i++; + } + } + } + + private static void EmitOwnAssignmentBinary(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.AssignmentBinary)node; + if (n.Expression is { } c_expression) + trap.Tuple("assignment_binary_expressions", id, Child(trap, children, c_expression)); + } + + private static void EmitOwnAssignmentEventHandlerBase(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.AssignmentEventHandlerBase)node; + if (n.Addition is true) + trap.Tuple("assignment_event_handler_base_addition", id); + if (n.Name is string s_name) + trap.Tuple("assignment_event_handler_base_names", id, s_name); + } + + private static void EmitOwnAssignmentEventHandlerInstance(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.AssignmentEventHandlerInstance)node; + if (n.QualifierPart is { } c_qualifier_part) + trap.Tuple("assignment_event_handler_instance_qualifier_parts", id, Child(trap, children, c_qualifier_part)); + } + + private static void EmitOwnAssignmentEventHandlerStatic(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.AssignmentEventHandlerStatic)node; + if (n.TypeName is string s_type_name) + trap.Tuple("assignment_event_handler_static_type_names", id, s_type_name); + } + + private static void EmitOwnAssignmentSingleField(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.AssignmentSingleField)node; + if (n.Field is { } c_field) + trap.Tuple("assignment_single_field_fields", id, Child(trap, children, c_field)); + } + + private static void EmitOwnAttribute(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.Attribute)node; + if (n.Name is string s_name) + trap.Tuple("attribute_names", id, s_name); + { + var i = 0; + foreach (var item in AstSequence.Elements(n.NamedParameters)) + { + trap.Tuple("attribute_named_parameters", id, i, EmitAttributeNamedParameterEntry(trap, children, (ITuple)item)); + i++; + } + } + if (n.NonFullyQualifiedName is string s_non_fully_qualified_name) + trap.Tuple("attribute_non_fully_qualified_names", id, s_non_fully_qualified_name); + { + var i = 0; + foreach (var item in AstSequence.Elements(n.Parameters)) + { + trap.Tuple("attribute_parameters", id, i, Child(trap, children, item)); + i++; + } + } + } + + private static void EmitOwnAttributeExpression(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.AttributeExpression)node; + if (n.Literal is { } c_literal) + trap.Tuple("attribute_expression_literals", id, Child(trap, children, c_literal)); + } + + private static void EmitOwnAttributeList(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.AttributeList)node; + { + var i = 0; + foreach (var item in AstSequence.Elements(n.Attributes)) + { + trap.Tuple("attribute_list_attributes", id, i, Child(trap, children, item)); + i++; + } + } + if (n.ContainsInternalUseOnlyAttribute is true) + trap.Tuple("attribute_list_contains_internal_use_only_attribute", id); + } + + private static void EmitOwnBinaryExpression(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.BinaryExpression)node; + if (n.Left is { } c_left) + trap.Tuple("binary_expression_lefts", id, Child(trap, children, c_left)); + if (n.Right is { } c_right) + trap.Tuple("binary_expression_rights", id, Child(trap, children, c_right)); + } + + private static void EmitOwnCaseValues(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.CaseValues)node; + { + var i = 0; + foreach (var item in AstSequence.Elements(n.Values)) + { + trap.Tuple("case_values_values", id, i, Child(trap, children, item)); + i++; + } + } + } + + private static void EmitOwnCatchExpression(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.CatchExpression)node; + if (n.Expression is { } c_expression) + trap.Tuple("catch_expression_expressions", id, Child(trap, children, c_expression)); + } + + private static void EmitOwnCatchUpdateConflict(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.CatchUpdateConflict)node; + if (n.Expression is { } c_expression) + trap.Tuple("catch_update_conflict_expressions", id, Child(trap, children, c_expression)); + if (n.Instance is { } c_instance) + trap.Tuple("catch_update_conflict_instances", id, Child(trap, children, c_instance)); + } + + private static void EmitOwnChangeStatement(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.ChangeStatement)node; + if (n.Expression is { } c_expression) + trap.Tuple("change_statement_expressions", id, Child(trap, children, c_expression)); + if (n.Statement is { } c_statement) + trap.Tuple("change_statement_statements", id, Child(trap, children, c_statement)); + } + + private static void EmitOwnClass(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.Class)node; + { + var i = 0; + foreach (var item in AstSequence.Elements(n.Fields)) + { + trap.Tuple("class_fields", id, i, Child(trap, children, item)); + i++; + } + } + if (n.HasCyclicInheritance is true) + trap.Tuple("class_has_cyclic_inheritance", id); + { + var i = 0; + foreach (var item in AstSequence.Elements(n.Implements)) + { + trap.Tuple("class_implements", id, i, (string)item); + i++; + } + } + } + + private static void EmitOwnClassAccessModifier(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.ClassAccessModifier)node; + if (n.ClassModifiers is { } e_class_modifiers) + trap.Tuple("class_access_modifier_class_modifiers", id, e_class_modifiers.ToString()); + } + + private static void EmitOwnClassOrInterface(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.ClassOrInterface)node; + if (n.Attributes is { } c_attributes) + trap.Tuple("class_or_interface_attributes", id, Child(trap, children, c_attributes)); + if (n.ElementTypeName is string s_element_type_name) + trap.Tuple("class_or_interface_element_type_names", id, s_element_type_name); + if (n.EnclosingType is { } c_enclosing_type) + trap.Tuple("class_or_interface_enclosing_types", id, Child(trap, children, c_enclosing_type)); + if (n.Extends is string s_extends) + trap.Tuple("class_or_interface_extends", id, s_extends); + if (n.IsAbstract is true) + trap.Tuple("class_or_interface_is_abstract", id); + if (n.IsCompositeDataEntityView is true) + trap.Tuple("class_or_interface_is_composite_data_entity_view", id); + if (n.IsFinal is true) + trap.Tuple("class_or_interface_is_final", id); + if (n.IsNested is true) + trap.Tuple("class_or_interface_is_nested", id); + if (n.IsStatic is true) + trap.Tuple("class_or_interface_is_static", id); + if (n.Qualifier is string s_qualifier) + trap.Tuple("class_or_interface_qualifiers", id, s_qualifier); + } + + private static void EmitOwnClrEnumerationLiteralExpression(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.ClrEnumerationLiteralExpression)node; + if (n.EnumerationLiteral is string s_enumeration_literal) + trap.Tuple("clr_enumeration_literal_expression_enumeration_literals", id, s_enumeration_literal); + if (n.EnumerationType is string s_enumeration_type) + trap.Tuple("clr_enumeration_literal_expression_enumeration_types", id, s_enumeration_type); + } + + private static void EmitOwnClrType(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.ClrType)node; + if (n.FullName is string s_full_name) + trap.Tuple("clr_type_full_names", id, s_full_name); + { + var i = 0; + foreach (var item in AstSequence.Elements(n.RectangularDimensions)) + { + trap.Tuple("clr_type_rectangular_dimensions", id, i, System.Convert.ToInt64(item)); + i++; + } + } + } + + private static void EmitOwnCompilationUnit(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.CompilationUnit)node; + if (n.Comments is { } c_comments) + trap.Tuple("compilation_unit_comments", id, Child(trap, children, c_comments)); + if (n.IsNameEscaped is true) + trap.Tuple("compilation_unit_is_name_escaped", id); + if (n.Name is string s_name) + trap.Tuple("compilation_unit_names", id, s_name); + if (n.NeedsTransformation is true) + trap.Tuple("compilation_unit_needs_transformation", id); + { + var i = 0; + foreach (var item in AstSequence.Elements(n.Regions)) + { + trap.Tuple("compilation_unit_regions", id, i, EmitCompilationUnitRegionEntry(trap, children, (ITuple)item)); + i++; + } + } + } + + private static void EmitOwnCompoundStatement(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.CompoundStatement)node; + { + var i = 0; + foreach (var item in AstSequence.Elements(n.Content)) + { + trap.Tuple("compound_statement_contents", id, i, Child(trap, children, item)); + i++; + } + } + } + + private static void EmitOwnConditionalExpression(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.ConditionalExpression)node; + if (n.Condition is { } c_condition) + trap.Tuple("conditional_expression_conditions", id, Child(trap, children, c_condition)); + if (n.ElsePart is { } c_else_part) + trap.Tuple("conditional_expression_else_parts", id, Child(trap, children, c_else_part)); + if (n.IfPart is { } c_if_part) + trap.Tuple("conditional_expression_if_parts", id, Child(trap, children, c_if_part)); + } + + private static void EmitOwnContainerAttributeLiteral(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.ContainerAttributeLiteral)node; + { + var i = 0; + foreach (var item in AstSequence.Elements(n.Value)) + { + trap.Tuple("container_attribute_literal_values", id, i, Child(trap, children, item)); + i++; + } + } + } + + private static void EmitOwnContainerLiteralExpression(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.ContainerLiteralExpression)node; + { + var i = 0; + foreach (var item in AstSequence.Elements(n.Value)) + { + trap.Tuple("container_literal_expression_values", id, i, Child(trap, children, item)); + i++; + } + } + } + + private static void EmitOwnCrossCompanyContainer(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.CrossCompanyContainer)node; + if (n.Container is { } c_container) + trap.Tuple("cross_company_container_containers", id, Child(trap, children, c_container)); + } + + private static void EmitOwnDeclaration(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.Declaration)node; + if (n.ArraySpecification is { } c_array_specification) + trap.Tuple("declaration_array_specifications", id, Child(trap, children, c_array_specification)); + { + var i = 0; + foreach (var item in AstSequence.Elements(n.ModifierList)) + { + trap.Tuple("declaration_modifier_lists", id, i, Child(trap, children, item)); + i++; + } + } + if (n.Modifiers is { } e_modifiers) + trap.Tuple("declaration_modifiers", id, e_modifiers.ToString()); + if (n.Type is { } c_type) + trap.Tuple("declaration_types", id, Child(trap, children, c_type)); + } + + private static void EmitOwnDefaultTypeAttributeLiteral(ITrapFile trap, Label id, object node, ICollection children) + { + dynamic n = node; + if (n.ScannedLiteralValue is string s_scanned_literal_value) + trap.Tuple("default_type_attribute_literal_scanned_literal_values", id, s_scanned_literal_value); + } + + private static void EmitOwnDefaultTypeLiteralExpression(ITrapFile trap, Label id, object node, ICollection children) + { + dynamic n = node; + if (n.ScannedLiteralValue is string s_scanned_literal_value) + trap.Tuple("default_type_literal_expression_scanned_literal_values", id, s_scanned_literal_value); + } + + private static void EmitOwnDelegate(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.Delegate)node; + if (n.IsStatic is true) + trap.Tuple("delegate_is_static", id); + } + + private static void EmitOwnDeleteStatement(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.DeleteStatement)node; + if (n.Query is { } c_query) + trap.Tuple("delete_statement_queries", id, Child(trap, children, c_query)); + } + + private static void EmitOwnDoWhileStatement(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.DoWhileStatement)node; + if (n.Condition is { } c_condition) + trap.Tuple("do_while_statement_conditions", id, Child(trap, children, c_condition)); + if (n.Statement is { } c_statement) + trap.Tuple("do_while_statement_statements", id, Child(trap, children, c_statement)); + } + + private static void EmitOwnEnumAttributeLiteral(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.EnumAttributeLiteral)node; + if (n.Literal is string s_literal) + trap.Tuple("enum_attribute_literal_literals", id, s_literal); + if (n.TypeName is string s_type_name) + trap.Tuple("enum_attribute_literal_type_names", id, s_type_name); + } + + private static void EmitOwnEnumerationLiteralExpression(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.EnumerationLiteralExpression)node; + if (n.EnumerationLiteral is string s_enumeration_literal) + trap.Tuple("enumeration_literal_expression_enumeration_literals", id, s_enumeration_literal); + if (n.EnumerationType is string s_enumeration_type) + trap.Tuple("enumeration_literal_expression_enumeration_types", id, s_enumeration_type); + } + + private static void EmitOwnEnumerationType(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.EnumerationType)node; + if (n.EnumeratedType is string s_enumerated_type) + trap.Tuple("enumeration_type_enumerated_types", id, s_enumerated_type); + if (n.FullName is string s_full_name) + trap.Tuple("enumeration_type_full_names", id, s_full_name); + if (n.Namespace is string s_namespace) + trap.Tuple("enumeration_type_namespaces", id, s_namespace); + } + + private static void EmitOwnEvaluation(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.Evaluation)node; + { + var i = 0; + foreach (var item in AstSequence.Elements(n.ActualParameters)) + { + trap.Tuple("evaluation_actual_parameters", id, i, EmitEvaluationActualParameterEntry(trap, children, (ITuple)item)); + i++; + } + } + } + + private static void EmitOwnExplicitSelection(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.ExplicitSelection)node; + { + var i = 0; + foreach (var item in AstSequence.Elements(n.Fields)) + { + trap.Tuple("explicit_selection_fields", id, i, Child(trap, children, item)); + i++; + } + } + } + + private static void EmitOwnExpression(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.Expression)node; + if (n.IsConst is true) + trap.Tuple("expression_is_const", id); + if (n.Transformation is { } c_transformation) + trap.Tuple("expression_transformations", id, Child(trap, children, c_transformation)); + } + + private static void EmitOwnExpressionCompilationUnit(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.ExpressionCompilationUnit)node; + if (n.Expression is { } c_expression) + trap.Tuple("expression_compilation_unit_expressions", id, Child(trap, children, c_expression)); + if (n.PathContribution is string s_path_contribution) + trap.Tuple("expression_compilation_unit_path_contributions", id, s_path_contribution); + } + + private static void EmitOwnExpressionQualifier(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.ExpressionQualifier)node; + if (n.Expression is { } c_expression) + trap.Tuple("expression_qualifier_expressions", id, Child(trap, children, c_expression)); + } + + private static void EmitOwnExpressionStatement(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.ExpressionStatement)node; + if (n.ElementTypeName is string s_element_type_name) + trap.Tuple("expression_statement_element_type_names", id, s_element_type_name); + if (n.Expression is { } c_expression) + trap.Tuple("expression_statement_expressions", id, Child(trap, children, c_expression)); + } + + private static void EmitOwnFieldAssignment(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.FieldAssignment)node; + if (n.Expression is { } c_expression) + trap.Tuple("field_assignment_expressions", id, Child(trap, children, c_expression)); + if (n.ExtensionName is string s_extension_name) + trap.Tuple("field_assignment_extension_names", id, s_extension_name); + if (n.FieldName is string s_field_name) + trap.Tuple("field_assignment_field_names", id, s_field_name); + if (n.Index is { } v_index) + trap.Tuple("field_assignment_indices", id, System.Convert.ToInt64(v_index)); + } + + private static void EmitOwnFieldDeclaration(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.FieldDeclaration)node; + if (n.Attributes is { } c_attributes) + trap.Tuple("field_declaration_attributes", id, Child(trap, children, c_attributes)); + if (n.ElementTypeName is string s_element_type_name) + trap.Tuple("field_declaration_element_type_names", id, s_element_type_name); + if (n.ExtensionName is string s_extension_name) + trap.Tuple("field_declaration_extension_names", id, s_extension_name); + if (n.InitialValue is { } c_initial_value) + trap.Tuple("field_declaration_initial_values", id, Child(trap, children, c_initial_value)); + if (n.IsConst is true) + trap.Tuple("field_declaration_is_const", id); + if (n.IsExtension is true) + trap.Tuple("field_declaration_is_extension", id); + if (n.IsInternal is true) + trap.Tuple("field_declaration_is_internal", id); + if (n.IsObsolete is true) + trap.Tuple("field_declaration_is_obsolete", id); + if (n.IsPrivate is true) + trap.Tuple("field_declaration_is_private", id); + if (n.IsProtected is true) + trap.Tuple("field_declaration_is_protected", id); + if (n.IsPublic is true) + trap.Tuple("field_declaration_is_public", id); + if (n.IsReadOnly is true) + trap.Tuple("field_declaration_is_read_only", id); + if (n.IsStatic is true) + trap.Tuple("field_declaration_is_static", id); + } + + private static void EmitOwnFieldExpression(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.FieldExpression)node; + if (n.Field is { } c_field) + trap.Tuple("field_expression_fields", id, Child(trap, children, c_field)); + if (n.IsEnum is true) + trap.Tuple("field_expression_is_enum", id); + } + + private static void EmitOwnFieldSelection(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.FieldSelection)node; + if (n.Index is { } v_index) + trap.Tuple("field_selection_indices", id, System.Convert.ToInt64(v_index)); + } + + private static void EmitOwnFieldSpecification(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.FieldSpecification)node; + if (n.ArrayIndex is { } c_array_index) + trap.Tuple("field_specification_array_indices", id, Child(trap, children, c_array_index)); + if (n.ElementTypeName is string s_element_type_name) + trap.Tuple("field_specification_element_type_names", id, s_element_type_name); + if (n.IsConst is true) + trap.Tuple("field_specification_is_const", id); + if (n.IsInternal is true) + trap.Tuple("field_specification_is_internal", id); + if (n.IsPrivate is true) + trap.Tuple("field_specification_is_private", id); + if (n.IsProtected is true) + trap.Tuple("field_specification_is_protected", id); + if (n.IsPublic is true) + trap.Tuple("field_specification_is_public", id); + if (n.IsReadOnly is true) + trap.Tuple("field_specification_is_read_only", id); + if (n.IsStatic is true) + trap.Tuple("field_specification_is_static", id); + if (n.Qualifier is { } c_qualifier) + trap.Tuple("field_specification_qualifiers", id, Child(trap, children, c_qualifier)); + } + + private static void EmitOwnFindStatement(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.FindStatement)node; + if (n.Query is { } c_query) + trap.Tuple("find_statement_queries", id, Child(trap, children, c_query)); + } + + private static void EmitOwnFlushStatement(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.FlushStatement)node; + { + var i = 0; + foreach (var item in AstSequence.Elements(n.IdList)) + { + trap.Tuple("flush_statement_id_lists", id, i, (string)item); + i++; + } + } + } + + private static void EmitOwnForAssign(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.ForAssign)node; + if (n.FieldSpecification is { } c_field_specification) + trap.Tuple("for_assign_field_specifications", id, Child(trap, children, c_field_specification)); + } + + private static void EmitOwnForDeclarationAssign(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.ForDeclarationAssign)node; + { + var i = 0; + foreach (var item in AstSequence.Elements(n.InitializationDeclaration)) + { + trap.Tuple("for_declaration_assign_initialization_declarations", id, i, Child(trap, children, item)); + i++; + } + } + } + + private static void EmitOwnForExpressionAssign(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.ForExpressionAssign)node; + if (n.Expression is { } c_expression) + trap.Tuple("for_expression_assign_expressions", id, Child(trap, children, c_expression)); + } + + private static void EmitOwnForStatement(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.ForStatement)node; + if (n.Condition is { } c_condition) + trap.Tuple("for_statement_conditions", id, Child(trap, children, c_condition)); + if (n.Initialization is { } c_initialization) + trap.Tuple("for_statement_initializations", id, Child(trap, children, c_initialization)); + if (n.Statement is { } c_statement) + trap.Tuple("for_statement_statements", id, Child(trap, children, c_statement)); + if (n.Update is { } c_update) + trap.Tuple("for_statement_updates", id, Child(trap, children, c_update)); + } + + private static void EmitOwnFormControl(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.FormControl)node; + if (n.AutoDeclaration is true) + trap.Tuple("form_control_auto_declaration", id); + { + var i = 0; + foreach (var item in AstSequence.Elements(n.ChildControls)) + { + trap.Tuple("form_control_child_controls", id, i, Child(trap, children, item)); + i++; + } + } + if (n.ControlClass is string s_control_class) + trap.Tuple("form_control_control_classes", id, s_control_class); + if (n.ControlType is { } e_control_type) + trap.Tuple("form_control_control_types", id, e_control_type.ToString()); + if (n.CustomControlClass is string s_custom_control_class) + trap.Tuple("form_control_custom_control_classes", id, s_custom_control_class); + if (n.ElementTypeName is string s_element_type_name) + trap.Tuple("form_control_element_type_names", id, s_element_type_name); + if (n.InternalControlName is string s_internal_control_name) + trap.Tuple("form_control_internal_control_names", id, s_internal_control_name); + if (n.IsFormControlExtension is true) + trap.Tuple("form_control_is_form_control_extension", id); + if (n.ParentControl is { } c_parent_control) + trap.Tuple("form_control_parent_controls", id, Child(trap, children, c_parent_control)); + } + + private static void EmitOwnFormDataField(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.FormDataField)node; + if (n.ElementTypeName is string s_element_type_name) + trap.Tuple("form_data_field_element_type_names", id, s_element_type_name); + if (n.FormDataSource is { } c_form_data_source) + trap.Tuple("form_data_field_form_data_sources", id, Child(trap, children, c_form_data_source)); + } + + private static void EmitOwnFormDataSource(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.FormDataSource)node; + { + var i = 0; + foreach (var item in AstSequence.Elements(n.DataFields)) + { + trap.Tuple("form_data_source_data_fields", id, i, Child(trap, children, item)); + i++; + } + } + if (n.ElementTypeName is string s_element_type_name) + trap.Tuple("form_data_source_element_type_names", id, s_element_type_name); + if (n.JoinSource is string s_join_source) + trap.Tuple("form_data_source_join_sources", id, s_join_source); + if (n.LinkType is { } e_link_type) + trap.Tuple("form_data_source_link_types", id, e_link_type.ToString()); + if (n.NestedDataSource is true) + trap.Tuple("form_data_source_nested_data_source", id); + if (n.Query is { } c_query) + trap.Tuple("form_data_source_queries", id, Child(trap, children, c_query)); + if (n.QueryName is string s_query_name) + trap.Tuple("form_data_source_query_names", id, s_query_name); + if (n.Table is string s_table) + trap.Tuple("form_data_source_tables", id, s_table); + } + + private static void EmitOwnFormElementType(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.FormElementType)node; + if (n.FormName is string s_form_name) + trap.Tuple("form_element_type_form_names", id, s_form_name); + } + + private static void EmitOwnFormModelElement(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.FormModelElement)node; + if (n.Behavior is { } c_behavior) + trap.Tuple("form_model_element_behaviors", id, Child(trap, children, c_behavior)); + { + var i = 0; + foreach (var item in AstSequence.Elements(n.Controls)) + { + trap.Tuple("form_model_element_controls", id, i, Child(trap, children, item)); + i++; + } + } + { + var i = 0; + foreach (var item in AstSequence.Elements(n.DataSources)) + { + trap.Tuple("form_model_element_data_sources", id, i, Child(trap, children, item)); + i++; + } + } + if (n.ElementTypeName is string s_element_type_name) + trap.Tuple("form_model_element_element_type_names", id, s_element_type_name); + if (n.FullTypeName is string s_full_type_name) + trap.Tuple("form_model_element_full_type_names", id, s_full_type_name); + } + + private static void EmitOwnFormNestedElement(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.FormNestedElement)node; + if (n.Form is { } c_form) + trap.Tuple("form_nested_element_forms", id, Child(trap, children, c_form)); + } + + private static void EmitOwnFunctionCall(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.FunctionCall)node; + if (n.FunctionName is string s_function_name) + trap.Tuple("function_call_function_names", id, s_function_name); + } + + private static void EmitOwnFunctionDeclaration(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.FunctionDeclaration)node; + { + var i = 0; + foreach (var item in AstSequence.Elements(n.DeclarationsAndStatements)) + { + trap.Tuple("function_declaration_declarations_and_statements", id, i, Child(trap, children, item)); + i++; + } + } + if (n.ElementTypeName is string s_element_type_name) + trap.Tuple("function_declaration_element_type_names", id, s_element_type_name); + { + var i = 0; + foreach (var item in AstSequence.Elements(n.Locals)) + { + trap.Tuple("function_declaration_locals", id, i, Child(trap, children, item)); + i++; + } + } + { + var i = 0; + foreach (var item in AstSequence.Elements(n.Parameters)) + { + trap.Tuple("function_declaration_parameters", id, i, Child(trap, children, item)); + i++; + } + } + { + var i = 0; + foreach (var item in AstSequence.Elements(n.Statements)) + { + trap.Tuple("function_declaration_statements", id, i, Child(trap, children, item)); + i++; + } + } + } + + private static void EmitOwnGenericEvaluation(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.GenericEvaluation)node; + { + var i = 0; + foreach (var item in AstSequence.Elements(n.TypeArgumentList)) + { + trap.Tuple("generic_evaluation_type_argument_lists", id, i, Child(trap, children, item)); + i++; + } + } + } + + private static void EmitOwnGenericXppType(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.GenericXppType)node; + { + var i = 0; + foreach (var item in AstSequence.Elements(n.TypeArgumentList)) + { + trap.Tuple("generic_xpp_type_type_argument_lists", id, i, Child(trap, children, item)); + i++; + } + } + } + + private static void EmitOwnGlobalOrderElement(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.GlobalOrderElement)node; + if (n.ExtensionName is string s_extension_name) + trap.Tuple("global_order_element_extension_names", id, s_extension_name); + if (n.Table is string s_table) + trap.Tuple("global_order_element_tables", id, s_table); + } + + private static void EmitOwnIfStatement(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.IfStatement)node; + if (n.Condition is { } c_condition) + trap.Tuple("if_statement_conditions", id, Child(trap, children, c_condition)); + if (n.Consequent is { } c_consequent) + trap.Tuple("if_statement_consequents", id, Child(trap, children, c_consequent)); + } + + private static void EmitOwnIfThenElseStatement(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.IfThenElseStatement)node; + if (n.Antecedent is { } c_antecedent) + trap.Tuple("if_then_else_statement_antecedents", id, Child(trap, children, c_antecedent)); + if (n.Condition is { } c_condition) + trap.Tuple("if_then_else_statement_conditions", id, Child(trap, children, c_condition)); + if (n.Consequent is { } c_consequent) + trap.Tuple("if_then_else_statement_consequents", id, Child(trap, children, c_consequent)); + } + + private static void EmitOwnInsertFieldSpecification(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.InsertFieldSpecification)node; + if (n.ArrayIndex is { } v_array_index) + trap.Tuple("insert_field_specification_array_indices", id, System.Convert.ToInt64(v_array_index)); + if (n.ExtensionName is string s_extension_name) + trap.Tuple("insert_field_specification_extension_names", id, s_extension_name); + if (n.IsExtension is true) + trap.Tuple("insert_field_specification_is_extension", id); + if (n.Name is string s_name) + trap.Tuple("insert_field_specification_names", id, s_name); + } + + private static void EmitOwnInsertStatement(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.InsertStatement)node; + if (n.CrossCompany is { } c_cross_company) + trap.Tuple("insert_statement_cross_companies", id, Child(trap, children, c_cross_company)); + { + var i = 0; + foreach (var item in AstSequence.Elements(n.Fields)) + { + trap.Tuple("insert_statement_fields", id, i, Child(trap, children, item)); + i++; + } + } + if (n.Query is { } c_query) + trap.Tuple("insert_statement_queries", id, Child(trap, children, c_query)); + if (n.Table is string s_table) + trap.Tuple("insert_statement_tables", id, s_table); + } + + private static void EmitOwnIntrinsic(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.Intrinsic)node; + if (n.Arg1 is string s_arg1) + trap.Tuple("intrinsic_arg1s", id, s_arg1); + if (n.Arg2 is string s_arg2) + trap.Tuple("intrinsic_arg2s", id, s_arg2); + if (n.Arg3 is string s_arg3) + trap.Tuple("intrinsic_arg3s", id, s_arg3); + if (n.Name is string s_name) + trap.Tuple("intrinsic_names", id, s_name); + } + + private static void EmitOwnIntrinsicAttributeLiteral(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.IntrinsicAttributeLiteral)node; + if (n.Arg1 is string s_arg1) + trap.Tuple("intrinsic_attribute_literal_arg1s", id, s_arg1); + if (n.Arg2 is string s_arg2) + trap.Tuple("intrinsic_attribute_literal_arg2s", id, s_arg2); + if (n.Arg3 is string s_arg3) + trap.Tuple("intrinsic_attribute_literal_arg3s", id, s_arg3); + if (n.FunctionName is string s_function_name) + trap.Tuple("intrinsic_attribute_literal_function_names", id, s_function_name); + } + + private static void EmitOwnIsAsExpression(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.IsAsExpression)node; + if (n.Expression is { } c_expression) + trap.Tuple("is_as_expression_expressions", id, Child(trap, children, c_expression)); + if (n.TypeName is string s_type_name) + trap.Tuple("is_as_expression_type_names", id, s_type_name); + } + + private static void EmitOwnJoinSpecification(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.JoinSpecification)node; + if (n.Kind is { } e_kind) + trap.Tuple("join_specification_kinds", id, e_kind.ToString()); + if (n.Query is { } c_query) + trap.Tuple("join_specification_queries", id, Child(trap, children, c_query)); + } + + private static void EmitOwnLocalDeclarationsStatement(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.LocalDeclarationsStatement)node; + { + var i = 0; + foreach (var item in AstSequence.Elements(n.Declarations)) + { + trap.Tuple("local_declarations_statement_declarations", id, i, Child(trap, children, item)); + i++; + } + } + } + + private static void EmitOwnMethod(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.Method)node; + { + var i = 0; + foreach (var item in AstSequence.Elements(n.DeclarationsAndStatements)) + { + trap.Tuple("method_declarations_and_statements", id, i, Child(trap, children, item)); + i++; + } + } + if (n.HasLocalFunctions is true) + trap.Tuple("method_has_local_functions", id); + if (n.IsAbstract is true) + trap.Tuple("method_is_abstract", id); + if (n.IsClient is true) + trap.Tuple("method_is_client", id); + if (n.IsConstructor is true) + trap.Tuple("method_is_constructor", id); + if (n.IsDisplay is true) + trap.Tuple("method_is_display", id); + if (n.IsEdit is true) + trap.Tuple("method_is_edit", id); + if (n.IsExplicitNonHookable is true) + trap.Tuple("method_is_explicit_non_hookable", id); + if (n.IsExplicitNonWrappable is true) + trap.Tuple("method_is_explicit_non_wrappable", id); + if (n.IsExtendedMethod is true) + trap.Tuple("method_is_extended_method", id); + if (n.IsFinal is true) + trap.Tuple("method_is_final", id); + if (n.IsHookable is true) + trap.Tuple("method_is_hookable", id); + if (n.IsHookableOnChainOfCommand is true) + trap.Tuple("method_is_hookable_on_chain_of_command", id); + if (n.IsInternal is true) + trap.Tuple("method_is_internal", id); + if (n.IsPrivate is true) + trap.Tuple("method_is_private", id); + if (n.IsProtected is true) + trap.Tuple("method_is_protected", id); + if (n.IsPublic is true) + trap.Tuple("method_is_public", id); + if (n.IsReplaceable is true) + trap.Tuple("method_is_replaceable", id); + if (n.IsServer is true) + trap.Tuple("method_is_server", id); + if (n.IsStatic is true) + trap.Tuple("method_is_static", id); + if (n.IsTypeInitializer is true) + trap.Tuple("method_is_type_initializer", id); + if (n.IsWrappable is true) + trap.Tuple("method_is_wrappable", id); + { + var i = 0; + foreach (var item in AstSequence.Elements(n.Locals)) + { + trap.Tuple("method_locals", id, i, Child(trap, children, item)); + i++; + } + } + if (n.Modifiers is { } e_modifiers) + trap.Tuple("method_modifiers", id, e_modifiers.ToString()); + { + var i = 0; + foreach (var item in AstSequence.Elements(n.Statements)) + { + trap.Tuple("method_statements", id, i, Child(trap, children, item)); + i++; + } + } + } + + private static void EmitOwnMethodOrDelegate(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.MethodOrDelegate)node; + if (n.Attributes is { } c_attributes) + trap.Tuple("method_or_delegate_attributes", id, Child(trap, children, c_attributes)); + { + var i = 0; + foreach (var item in AstSequence.Elements(n.ModifierList)) + { + trap.Tuple("method_or_delegate_modifier_lists", id, i, Child(trap, children, item)); + i++; + } + } + { + var i = 0; + foreach (var item in AstSequence.Elements(n.Parameters)) + { + trap.Tuple("method_or_delegate_parameters", id, i, Child(trap, children, item)); + i++; + } + } + if (n.PathContribution is string s_path_contribution) + trap.Tuple("method_or_delegate_path_contributions", id, s_path_contribution); + if (n.Type is { } c_type) + trap.Tuple("method_or_delegate_types", id, Child(trap, children, c_type)); + { + var i = 0; + foreach (var item in AstSequence.Elements(n.TypeParameters)) + { + trap.Tuple("method_or_delegate_type_parameters", id, i, (string)item); + i++; + } + } + } + + private static void EmitOwnModelElement(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.ModelElement)node; + { + var i = 0; + foreach (var item in AstSequence.Elements(n.BaseMethods)) + { + trap.Tuple("model_element_base_methods", id, i, Child(trap, children, item)); + i++; + } + } + { + var i = 0; + foreach (var item in AstSequence.Elements(n.ExtendGenericParameters)) + { + trap.Tuple("model_element_extend_generic_parameters", id, i, Child(trap, children, item)); + i++; + } + } + if (n.FullName is string s_full_name) + trap.Tuple("model_element_full_names", id, s_full_name); + if (n.FullNameNoDefaultNamespace is string s_full_name_no_default_namespace) + trap.Tuple("model_element_full_name_no_default_namespaces", id, s_full_name_no_default_namespace); + if (n.IsInternal is true) + trap.Tuple("model_element_is_internal", id); + if (n.IsKernel is true) + trap.Tuple("model_element_is_kernel", id); + if (n.IsObsolete is true) + trap.Tuple("model_element_is_obsolete", id); + if (n.IsPrivate is true) + trap.Tuple("model_element_is_private", id); + if (n.IsPublic is true) + trap.Tuple("model_element_is_public", id); + { + var i = 0; + foreach (var item in AstSequence.Elements(n.Methods)) + { + trap.Tuple("model_element_methods", id, i, Child(trap, children, item)); + i++; + } + } + if (n.ModelId is { } v_model_id) + trap.Tuple("model_element_model_ids", id, System.Convert.ToInt64(v_model_id)); + { + var i = 0; + foreach (var item in AstSequence.Elements(n.ModifierList)) + { + trap.Tuple("model_element_modifier_lists", id, i, Child(trap, children, item)); + i++; + } + } + if (n.Modifiers is { } e_modifiers) + trap.Tuple("model_element_modifiers", id, e_modifiers.ToString()); + if (n.Namespace is string s_namespace) + trap.Tuple("model_element_namespaces", id, s_namespace); + { + var i = 0; + foreach (var item in AstSequence.Elements(n.NestedClasses)) + { + trap.Tuple("model_element_nested_classes", id, i, Child(trap, children, item)); + i++; + } + } + if (n.PathContribution is string s_path_contribution) + trap.Tuple("model_element_path_contributions", id, s_path_contribution); + { + var i = 0; + foreach (var item in AstSequence.Elements(n.TypeParameters)) + { + trap.Tuple("model_element_type_parameters", id, i, (string)item); + i++; + } + } + { + var i = 0; + foreach (var item in AstSequence.Elements(n.Using)) + { + trap.Tuple("model_element_usings", id, i, EmitModelElementUsingEntry(trap, children, (ITuple)item)); + i++; + } + } + if (n.Visibility is { } e_visibility) + trap.Tuple("model_element_visibilities", id, e_visibility.ToString()); + } + + private static void EmitOwnModifier(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.Modifier)node; + if (n.Modifiers is { } e_modifiers) + trap.Tuple("modifier_modifiers", id, e_modifiers.ToString()); + } + + private static void EmitOwnMoveCursorStatement(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.MoveCursorStatement)node; + if (n.Selection is { } c_selection) + trap.Tuple("move_cursor_statement_selections", id, Child(trap, children, c_selection)); + if (n.Table is string s_table) + trap.Tuple("move_cursor_statement_tables", id, s_table); + } + + private static void EmitOwnNamedFieldReference(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.NamedFieldReference)node; + if (n.ExtensionName is string s_extension_name) + trap.Tuple("named_field_reference_extension_names", id, s_extension_name); + if (n.FieldName is string s_field_name) + trap.Tuple("named_field_reference_field_names", id, s_field_name); + } + + private static void EmitOwnNamedType(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.NamedType)node; + if (n.Name is string s_name) + trap.Tuple("named_type_names", id, s_name); + } + + private static void EmitOwnNewCall(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.NewCall)node; + if (n.Type is { } c_type) + trap.Tuple("new_call_types", id, Child(trap, children, c_type)); + } + + private static void EmitOwnNewClrArrayExpression(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.NewClrArrayExpression)node; + if (n.FullName is string s_full_name) + trap.Tuple("new_clr_array_expression_full_names", id, s_full_name); + { + var i = 0; + foreach (var item in AstSequence.Elements(n.RectangularDimensions)) + { + trap.Tuple("new_clr_array_expression_rectangular_dimensions", id, i, System.Convert.ToInt64(item)); + i++; + } + } + { + var i = 0; + foreach (var item in AstSequence.Elements(n.Sizes)) + { + trap.Tuple("new_clr_array_expression_sizes", id, i, Child(trap, children, item)); + i++; + } + } + { + var i = 0; + foreach (var item in AstSequence.Elements(n.TypeArgumentList)) + { + trap.Tuple("new_clr_array_expression_type_argument_lists", id, i, Child(trap, children, item)); + i++; + } + } + } + + private static void EmitOwnNewClrCall(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.NewClrCall)node; + if (n.ClrClassName is string s_clr_class_name) + trap.Tuple("new_clr_call_clr_class_names", id, s_clr_class_name); + } + + private static void EmitOwnNextExpression(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.NextExpression)node; + if (n.Name is string s_name) + trap.Tuple("next_expression_names", id, s_name); + } + + private static void EmitOwnNumberedFieldReference(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.NumberedFieldReference)node; + if (n.FieldNumber is { } c_field_number) + trap.Tuple("numbered_field_reference_field_numbers", id, Child(trap, children, c_field_number)); + } + + private static void EmitOwnOrderElement(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.OrderElement)node; + if (n.Direction is { } e_direction) + trap.Tuple("order_element_directions", id, e_direction.ToString()); + if (n.Field is string s_field) + trap.Tuple("order_element_fields", id, s_field); + if (n.Index is { } v_index) + trap.Tuple("order_element_indices", id, System.Convert.ToInt64(v_index)); + } + + private static void EmitOwnParameterDeclaration(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.ParameterDeclaration)node; + if (n.IsByRef is true) + trap.Tuple("parameter_declaration_is_by_ref", id); + if (n.IsOptional is true) + trap.Tuple("parameter_declaration_is_optional", id); + } + + private static void EmitOwnPrintStatement(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.PrintStatement)node; + { + var i = 0; + foreach (var item in AstSequence.Elements(n.Expressions)) + { + trap.Tuple("print_statement_expressions", id, i, Child(trap, children, item)); + i++; + } + } + } + + private static void EmitOwnProvidedType(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.ProvidedType)node; + { + var i = 0; + foreach (var item in AstSequence.Elements(n.ArgumentList)) + { + trap.Tuple("provided_type_argument_lists", id, i, Child(trap, children, item)); + i++; + } + } + if (n.Name is string s_name) + trap.Tuple("provided_type_names", id, s_name); + } + + private static void EmitOwnProvidedTypeStaticCall(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.ProvidedTypeStaticCall)node; + if (n.MethodName is string s_method_name) + trap.Tuple("provided_type_static_call_method_names", id, s_method_name); + if (n.ProvidedType is { } c_provided_type) + trap.Tuple("provided_type_static_call_provided_types", id, Child(trap, children, c_provided_type)); + } + + private static void EmitOwnQualifiedCall(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.QualifiedCall)node; + if (n.MethodName is string s_method_name) + trap.Tuple("qualified_call_method_names", id, s_method_name); + if (n.Qualifier is { } c_qualifier) + trap.Tuple("qualified_call_qualifiers", id, Child(trap, children, c_qualifier)); + } + + private static void EmitOwnQualifiedField(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.QualifiedField)node; + if (n.ExtensionName is string s_extension_name) + trap.Tuple("qualified_field_extension_names", id, s_extension_name); + if (n.Name is string s_name) + trap.Tuple("qualified_field_names", id, s_name); + } + + private static void EmitOwnQualifiedInstanceName(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.QualifiedInstanceName)node; + if (n.Index is { } c_index) + trap.Tuple("qualified_instance_name_indices", id, Child(trap, children, c_index)); + if (n.Name is string s_name) + trap.Tuple("qualified_instance_name_names", id, s_name); + if (n.Qualifier is { } c_qualifier) + trap.Tuple("qualified_instance_name_qualifiers", id, Child(trap, children, c_qualifier)); + } + + private static void EmitOwnQualifiedNumberedField(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.QualifiedNumberedField)node; + if (n.FieldNumber is { } c_field_number) + trap.Tuple("qualified_numbered_field_field_numbers", id, Child(trap, children, c_field_number)); + } + + private static void EmitOwnQualifiedStaticCall(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.QualifiedStaticCall)node; + if (n.ClassName is string s_class_name) + trap.Tuple("qualified_static_call_class_names", id, s_class_name); + { + var i = 0; + foreach (var item in AstSequence.Elements(n.ClassTypeArgumentList)) + { + trap.Tuple("qualified_static_call_class_type_argument_lists", id, i, Child(trap, children, item)); + i++; + } + } + if (n.IsTableMapCall is true) + trap.Tuple("qualified_static_call_is_table_map_call", id); + if (n.MethodName is string s_method_name) + trap.Tuple("qualified_static_call_method_names", id, s_method_name); + if (n.Qualifier is { } c_qualifier) + trap.Tuple("qualified_static_call_qualifiers", id, Child(trap, children, c_qualifier)); + } + + private static void EmitOwnQualifiedStaticField(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.QualifiedStaticField)node; + if (n.ClassName is string s_class_name) + trap.Tuple("qualified_static_field_class_names", id, s_class_name); + if (n.IsEnum is true) + trap.Tuple("qualified_static_field_is_enum", id); + if (n.Name is string s_name) + trap.Tuple("qualified_static_field_names", id, s_name); + } + + private static void EmitOwnQualifiedStaticFieldExpression(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.QualifiedStaticFieldExpression)node; + if (n.ClassName is string s_class_name) + trap.Tuple("qualified_static_field_expression_class_names", id, s_class_name); + if (n.IsStatic is true) + trap.Tuple("qualified_static_field_expression_is_static", id); + if (n.Name is string s_name) + trap.Tuple("qualified_static_field_expression_names", id, s_name); + } + + private static void EmitOwnQuery(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.Query)node; + if (n.BufferName is string s_buffer_name) + trap.Tuple("query_buffer_names", id, s_buffer_name); + if (n.CrossCompany is { } c_cross_company) + trap.Tuple("query_cross_companies", id, Child(trap, children, c_cross_company)); + { + var i = 0; + foreach (var item in AstSequence.Elements(n.GroupByElements)) + { + trap.Tuple("query_group_by_elements", id, i, Child(trap, children, item)); + i++; + } + } + if (n.IndexName is string s_index_name) + trap.Tuple("query_index_names", id, s_index_name); + if (n.Joins is { } c_joins) + trap.Tuple("query_joins", id, Child(trap, children, c_joins)); + { + var i = 0; + foreach (var item in AstSequence.Elements(n.OrderByElements)) + { + trap.Tuple("query_order_by_elements", id, i, Child(trap, children, item)); + i++; + } + } + if (n.Selection is { } c_selection) + trap.Tuple("query_selections", id, Child(trap, children, c_selection)); + { + var i = 0; + foreach (var item in AstSequence.Elements(n.SelectionHints)) + { + trap.Tuple("query_selection_hints", id, i, item.ToString()); + i++; + } + } + if (n.UsesHint is true) + trap.Tuple("query_uses_hint", id); + if (n.ValidTimeState is { } c_valid_time_state) + trap.Tuple("query_valid_time_states", id, Child(trap, children, c_valid_time_state)); + if (n.Where is { } c_where) + trap.Tuple("query_wheres", id, Child(trap, children, c_where)); + } + + private static void EmitOwnQueryDataSource(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.QueryDataSource)node; + { + var i = 0; + foreach (var item in AstSequence.Elements(n.DataSources)) + { + trap.Tuple("query_data_source_data_sources", id, i, Child(trap, children, item)); + i++; + } + } + if (n.ElementTypeName is string s_element_type_name) + trap.Tuple("query_data_source_element_type_names", id, s_element_type_name); + if (n.FetchMode is { } e_fetch_mode) + trap.Tuple("query_data_source_fetch_modes", id, e_fetch_mode.ToString()); + { + var i = 0; + foreach (var item in AstSequence.Elements(n.Fields)) + { + trap.Tuple("query_data_source_fields", id, i, (string)item); + i++; + } + } + if (n.FirstFast is true) + trap.Tuple("query_data_source_first_fast", id); + if (n.FirstOnly is true) + trap.Tuple("query_data_source_first_only", id); + { + var i = 0; + foreach (var item in AstSequence.Elements(n.GroupBy)) + { + trap.Tuple("query_data_source_group_bies", id, i, Child(trap, children, item)); + i++; + } + } + { + var i = 0; + foreach (var item in AstSequence.Elements(n.Having)) + { + trap.Tuple("query_data_source_having_prop", id, i, Child(trap, children, item)); + i++; + } + } + if (n.JoinMode is { } e_join_mode) + trap.Tuple("query_data_source_join_modes", id, e_join_mode.ToString()); + if (n.Name is string s_name) + trap.Tuple("query_data_source_names", id, s_name); + { + var i = 0; + foreach (var item in AstSequence.Elements(n.OrderBy)) + { + trap.Tuple("query_data_source_order_bies", id, i, Child(trap, children, item)); + i++; + } + } + if (n.ParentDataSource is { } c_parent_data_source) + trap.Tuple("query_data_source_parent_data_sources", id, Child(trap, children, c_parent_data_source)); + if (n.PathContribution is string s_path_contribution) + trap.Tuple("query_data_source_path_contributions", id, s_path_contribution); + { + var i = 0; + foreach (var item in AstSequence.Elements(n.Ranges)) + { + trap.Tuple("query_data_source_ranges_prop", id, i, Child(trap, children, item)); + i++; + } + } + { + var i = 0; + foreach (var item in AstSequence.Elements(n.Relations)) + { + trap.Tuple("query_data_source_relations_prop", id, i, Child(trap, children, item)); + i++; + } + } + if (n.SelectWithRepeatableRead is true) + trap.Tuple("query_data_source_select_with_repeatable_read", id); + if (n.Table is string s_table) + trap.Tuple("query_data_source_tables", id, s_table); + if (n.Update is true) + trap.Tuple("query_data_source_update", id); + } + + private static void EmitOwnQueryDataSourceHaving(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.QueryDataSourceHaving)node; + if (n.DataSourceName is string s_data_source_name) + trap.Tuple("query_data_source_having_data_source_names", id, s_data_source_name); + if (n.Selection is { } c_selection) + trap.Tuple("query_data_source_having_selections", id, Child(trap, children, c_selection)); + if (n.Value is string s_value) + trap.Tuple("query_data_source_having_values", id, s_value); + } + + private static void EmitOwnQueryDataSourceRange(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.QueryDataSourceRange)node; + if (n.Field is string s_field) + trap.Tuple("query_data_source_range_fields", id, s_field); + if (n.Value is string s_value) + trap.Tuple("query_data_source_range_values", id, s_value); + } + + private static void EmitOwnQueryDataSourceRelation(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.QueryDataSourceRelation)node; + if (n.Field is string s_field) + trap.Tuple("query_data_source_relation_fields", id, s_field); + if (n.JoinDataSource is string s_join_data_source) + trap.Tuple("query_data_source_relation_join_data_sources", id, s_join_data_source); + if (n.RelatedField is string s_related_field) + trap.Tuple("query_data_source_relation_related_fields", id, s_related_field); + } + + private static void EmitOwnQueryModelElement(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.QueryModelElement)node; + if (n.AllowCrossCompany is true) + trap.Tuple("query_model_element_allow_cross_company", id); + if (n.Behavior is { } c_behavior) + trap.Tuple("query_model_element_behaviors", id, Child(trap, children, c_behavior)); + { + var i = 0; + foreach (var item in AstSequence.Elements(n.DataSourceList)) + { + trap.Tuple("query_model_element_data_source_lists", id, i, Child(trap, children, item)); + i++; + } + } + { + var i = 0; + foreach (var item in AstSequence.Elements(n.DataSources)) + { + trap.Tuple("query_model_element_data_sources", id, i, Child(trap, children, item)); + i++; + } + } + if (n.ElementTypeName is string s_element_type_name) + trap.Tuple("query_model_element_element_type_names", id, s_element_type_name); + if (n.UserUpdate is true) + trap.Tuple("query_model_element_user_update", id); + } + + private static void EmitOwnRelationalExpression(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.RelationalExpression)node; + if (n.Operator is string s_operator) + trap.Tuple("relational_expression_operators", id, s_operator); + } + + private static void EmitOwnReturnStatement(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.ReturnStatement)node; + if (n.Expression is { } c_expression) + trap.Tuple("return_statement_expressions", id, Child(trap, children, c_expression)); + } + + private static void EmitOwnSearchStatement(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.SearchStatement)node; + if (n.Query is { } c_query) + trap.Tuple("search_statement_queries", id, Child(trap, children, c_query)); + if (n.Statement is { } c_statement) + trap.Tuple("search_statement_statements", id, Child(trap, children, c_statement)); + } + + private static void EmitOwnSelectionField(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.SelectionField)node; + if (n.ExtensionName is string s_extension_name) + trap.Tuple("selection_field_extension_names", id, s_extension_name); + if (n.Field is string s_field) + trap.Tuple("selection_field_fields", id, s_field); + } + + private static void EmitOwnSimpleField(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.SimpleField)node; + if (n.ExtensionName is string s_extension_name) + trap.Tuple("simple_field_extension_names", id, s_extension_name); + if (n.IsNameEscaped is true) + trap.Tuple("simple_field_is_name_escaped", id); + if (n.Name is string s_name) + trap.Tuple("simple_field_names", id, s_name); + } + + private static void EmitOwnSimpleInstanceName(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.SimpleInstanceName)node; + if (n.Index is { } c_index) + trap.Tuple("simple_instance_name_indices", id, Child(trap, children, c_index)); + if (n.Name is string s_name) + trap.Tuple("simple_instance_name_names", id, s_name); + } + + private static void EmitOwnSimpleOrderElement(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.SimpleOrderElement)node; + if (n.ExtensionName is string s_extension_name) + trap.Tuple("simple_order_element_extension_names", id, s_extension_name); + } + + private static void EmitOwnSimpleQualifier(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.SimpleQualifier)node; + if (n.Name is string s_name) + trap.Tuple("simple_qualifier_names", id, s_name); + } + + private static void EmitOwnStatement(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.Statement)node; + if (n.Comments is string s_comments) + trap.Tuple("statement_comments", id, s_comments); + } + + private static void EmitOwnStaticField(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.StaticField)node; + if (n.ClassName is string s_class_name) + trap.Tuple("static_field_class_names", id, s_class_name); + if (n.Name is string s_name) + trap.Tuple("static_field_names", id, s_name); + } + + private static void EmitOwnStaticMethodCall(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.StaticMethodCall)node; + if (n.ClassName is string s_class_name) + trap.Tuple("static_method_call_class_names", id, s_class_name); + { + var i = 0; + foreach (var item in AstSequence.Elements(n.ClassTypeArgumentList)) + { + trap.Tuple("static_method_call_class_type_argument_lists", id, i, Child(trap, children, item)); + i++; + } + } + if (n.MethodName is string s_method_name) + trap.Tuple("static_method_call_method_names", id, s_method_name); + } + + private static void EmitOwnStaticQualifier(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.StaticQualifier)node; + { + var i = 0; + foreach (var item in AstSequence.Elements(n.ClassTypeArgumentList)) + { + trap.Tuple("static_qualifier_class_type_argument_lists", id, i, Child(trap, children, item)); + i++; + } + } + } + + private static void EmitOwnStringLengthType(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.StringLengthType)node; + if (n.EdtName is string s_edt_name) + trap.Tuple("string_length_type_edt_names", id, s_edt_name); + if (n.IsEdt is true) + trap.Tuple("string_length_type_is_edt", id); + if (n.Length is { } v_length) + trap.Tuple("string_length_type_lengths", id, System.Convert.ToInt64(v_length)); + } + + private static void EmitOwnStringLiteralExpression(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.StringLiteralExpression)node; + if (n.IsLabel is true) + trap.Tuple("string_literal_expression_is_label", id); + if (n.LabelFileId is string s_label_file_id) + trap.Tuple("string_literal_expression_label_file_ids", id, s_label_file_id); + if (n.LabelId is string s_label_id) + trap.Tuple("string_literal_expression_label_ids", id, s_label_id); + } + + private static void EmitOwnSwitchStatement(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.SwitchStatement)node; + { + var i = 0; + foreach (var item in AstSequence.Elements(n.Cases)) + { + trap.Tuple("switch_statement_cases", id, i, EmitSwitchStatementCaseEntry(trap, children, (ITuple)item)); + i++; + } + } + if (n.Selector is { } c_selector) + trap.Tuple("switch_statement_selectors", id, Child(trap, children, c_selector)); + } + + private static void EmitOwnTable(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.Table)node; + if (n.Attributes is { } c_attributes) + trap.Tuple("table_attributes", id, Child(trap, children, c_attributes)); + if (n.ElementTypeName is string s_element_type_name) + trap.Tuple("table_element_type_names", id, s_element_type_name); + if (n.Extends is string s_extends) + trap.Tuple("table_extends", id, s_extends); + { + var i = 0; + foreach (var item in AstSequence.Elements(n.Fields)) + { + trap.Tuple("table_fields", id, i, Child(trap, children, item)); + i++; + } + } + { + var i = 0; + foreach (var item in AstSequence.Elements(n.Indexes)) + { + trap.Tuple("table_indexes", id, i, (string)item); + i++; + } + } + if (n.IsAggregateDataEntity is true) + trap.Tuple("table_is_aggregate_data_entity", id); + if (n.IsDataEntityView is true) + trap.Tuple("table_is_data_entity_view", id); + if (n.IsMap is true) + trap.Tuple("table_is_map", id); + if (n.IsUpdatable is true) + trap.Tuple("table_is_updatable", id); + if (n.IsView is true) + trap.Tuple("table_is_view", id); + if (n.SupportInheritance is true) + trap.Tuple("table_support_inheritance", id); + } + + private static void EmitOwnTableFieldReference(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.TableFieldReference)node; + if (n.Index is { } c_index) + trap.Tuple("table_field_reference_indices", id, Child(trap, children, c_index)); + } + + private static void EmitOwnTableLookupExpression(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.TableLookupExpression)node; + if (n.Field is { } c_field) + trap.Tuple("table_lookup_expression_fields", id, Child(trap, children, c_field)); + if (n.Query is { } c_query) + trap.Tuple("table_lookup_expression_queries", id, Child(trap, children, c_query)); + } + + private static void EmitOwnThrowStatement(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.ThrowStatement)node; + if (n.Exception is { } c_exception) + trap.Tuple("throw_statement_exceptions", id, Child(trap, children, c_exception)); + } + + private static void EmitOwnTryStatement(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.TryStatement)node; + { + var i = 0; + foreach (var item in AstSequence.Elements(n.Catches)) + { + trap.Tuple("try_statement_catches", id, i, EmitTryStatementCatchEntry(trap, children, (ITuple)item)); + i++; + } + } + if (n.Finally is { } c_finally) + trap.Tuple("try_statement_finallies", id, Child(trap, children, c_finally)); + if (n.Statement is { } c_statement) + trap.Tuple("try_statement_statements", id, Child(trap, children, c_statement)); + } + + private static void EmitOwnUnaryExpression(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.UnaryExpression)node; + if (n.Expression is { } c_expression) + trap.Tuple("unary_expression_expressions", id, Child(trap, children, c_expression)); + } + + private static void EmitOwnUncheckedStatement(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.UncheckedStatement)node; + if (n.Expression is { } c_expression) + trap.Tuple("unchecked_statement_expressions", id, Child(trap, children, c_expression)); + if (n.Statement is { } c_statement) + trap.Tuple("unchecked_statement_statements", id, Child(trap, children, c_statement)); + } + + private static void EmitOwnUpdateStatement(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.UpdateStatement)node; + if (n.CrossCompany is { } c_cross_company) + trap.Tuple("update_statement_cross_companies", id, Child(trap, children, c_cross_company)); + { + var i = 0; + foreach (var item in AstSequence.Elements(n.FieldAssignments)) + { + trap.Tuple("update_statement_field_assignments", id, i, Child(trap, children, item)); + i++; + } + } + { + var i = 0; + foreach (var item in AstSequence.Elements(n.Hints)) + { + trap.Tuple("update_statement_hints", id, i, item.ToString()); + i++; + } + } + if (n.Joins is { } c_joins) + trap.Tuple("update_statement_joins", id, Child(trap, children, c_joins)); + if (n.Table is string s_table) + trap.Tuple("update_statement_tables", id, s_table); + if (n.Where is { } c_where) + trap.Tuple("update_statement_wheres", id, Child(trap, children, c_where)); + } + + private static void EmitOwnUsingStatement(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.UsingStatement)node; + { + var i = 0; + foreach (var item in AstSequence.Elements(n.DisposableObjectInitializers)) + { + trap.Tuple("using_statement_disposable_object_initializers", id, i, Child(trap, children, item)); + i++; + } + } + if (n.Statement is { } c_statement) + trap.Tuple("using_statement_statements", id, Child(trap, children, c_statement)); + } + + private static void EmitOwnValidTimeStateDate(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.ValidTimeStateDate)node; + if (n.DateVariable is string s_date_variable) + trap.Tuple("valid_time_state_date_date_variables", id, s_date_variable); + } + + private static void EmitOwnValidTimeStateRange(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.ValidTimeStateRange)node; + if (n.FromDateVariable is string s_from_date_variable) + trap.Tuple("valid_time_state_range_from_date_variables", id, s_from_date_variable); + if (n.ToDateVariable is string s_to_date_variable) + trap.Tuple("valid_time_state_range_to_date_variables", id, s_to_date_variable); + } + + private static void EmitOwnVariableDeclaration(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.VariableDeclaration)node; + if (n.ElementTypeName is string s_element_type_name) + trap.Tuple("variable_declaration_element_type_names", id, s_element_type_name); + if (n.InitialValue is { } c_initial_value) + trap.Tuple("variable_declaration_initial_values", id, Child(trap, children, c_initial_value)); + if (n.IsConst is true) + trap.Tuple("variable_declaration_is_const", id); + } + + private static void EmitOwnWhileStatement(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.WhileStatement)node; + if (n.Condition is { } c_condition) + trap.Tuple("while_statement_conditions", id, Child(trap, children, c_condition)); + if (n.Statement is { } c_statement) + trap.Tuple("while_statement_statements", id, Child(trap, children, c_statement)); + } + + private static void EmitOwnXppType(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.XppType)node; + if (n.ElementTypeName is string s_element_type_name) + trap.Tuple("xpp_type_element_type_names", id, s_element_type_name); + if (n.IsObsolete is true) + trap.Tuple("xpp_type_is_obsolete", id); + } + + private static void EmitOwnXppTypeCompilationUnit(ITrapFile trap, Label id, object node, ICollection children) + { + var n = (Microsoft.Dynamics.AX.Metadata.XppCompiler.XppTypeCompilationUnit)node; + if (n.Type is { } c_type) + trap.Tuple("xpp_type_compilation_unit_types", id, Child(trap, children, c_type)); + } + + private static Label EmitAttributeNamedParameterEntry(ITrapFile trap, ICollection children, ITuple tuple) + { + var id = trap.FreshLabel(); + trap.Tuple("attribute_named_parameter_entries", id); + if (tuple[0] is string s_item1) + trap.Tuple("attribute_named_parameter_entry_item1s", id, s_item1); + if (tuple[1] is { } c_attribute_expression) + trap.Tuple("attribute_named_parameter_entry_attribute_expressions", id, Child(trap, children, c_attribute_expression)); + return id; + } + + private static Label EmitCompilationUnitRegionEntry(ITrapFile trap, ICollection children, ITuple tuple) + { + var id = trap.FreshLabel(); + trap.Tuple("compilation_unit_region_entries", id); + if (tuple[0] is { } c_comment) + trap.Tuple("compilation_unit_region_entry_comments", id, Child(trap, children, c_comment)); + if (tuple[1] is { } c_comment2) + trap.Tuple("compilation_unit_region_entry_comment2s", id, Child(trap, children, c_comment2)); + return id; + } + + private static Label EmitEvaluationActualParameterEntry(ITrapFile trap, ICollection children, ITuple tuple) + { + var id = trap.FreshLabel(); + trap.Tuple("evaluation_actual_parameter_entries", id); + if (tuple[0] is true) + trap.Tuple("evaluation_actual_parameter_entry_item1", id); + if (tuple[1] is { } c_expression) + trap.Tuple("evaluation_actual_parameter_entry_expressions", id, Child(trap, children, c_expression)); + return id; + } + + private static Label EmitModelElementUsingEntry(ITrapFile trap, ICollection children, ITuple tuple) + { + var id = trap.FreshLabel(); + trap.Tuple("model_element_using_entries", id); + if (tuple[1] is string s_item2) + trap.Tuple("model_element_using_entry_item2s", id, s_item2); + if (tuple[2] is string s_item3) + trap.Tuple("model_element_using_entry_item3s", id, s_item3); + return id; + } + + private static Label EmitSwitchStatementCaseEntry(ITrapFile trap, ICollection children, ITuple tuple) + { + var id = trap.FreshLabel(); + trap.Tuple("switch_statement_case_entries", id); + if (tuple[0] is { } c_case) + trap.Tuple("switch_statement_case_entry_cases", id, Child(trap, children, c_case)); + { + var i = 0; + foreach (var item in AstSequence.Elements(tuple[1])) + { + trap.Tuple("switch_statement_case_entry_statements", id, i, Child(trap, children, item)); + i++; + } + } + return id; + } + + private static Label EmitTryStatementCatchEntry(ITrapFile trap, ICollection children, ITuple tuple) + { + var id = trap.FreshLabel(); + trap.Tuple("try_statement_catch_entries", id); + if (tuple[0] is { } c_catch) + trap.Tuple("try_statement_catch_entry_catches", id, Child(trap, children, c_catch)); + if (tuple[1] is { } c_statement) + trap.Tuple("try_statement_catch_entry_statements", id, Child(trap, children, c_statement)); + return id; + } + + /// + /// Writes every tuple describing , returning false when the + /// node's type is not part of the generated schema. + /// + public static bool Emit(ITrapFile trap, Label id, object node, ICollection children) + { + // Dispatch on the exact runtime type: C# type patterns also match subclasses, + // which would bind a node to an ancestor's table. + switch (node.GetType().FullName) + { + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.AddExpression": + trap.Tuple("add_expressions", id); + EmitOwnExpression(trap, id, node, children); + EmitOwnBinaryExpression(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.AllFieldsSelection": + trap.Tuple("all_fields_selections", id); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.AndExpression": + trap.Tuple("and_expressions", id); + EmitOwnExpression(trap, id, node, children); + EmitOwnBinaryExpression(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.AnyType": + trap.Tuple("any_types", id); + EmitOwnXppType(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.ArraySpecification": + trap.Tuple("array_specifications", id); + EmitOwnArraySpecification(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.AsClrExpression": + trap.Tuple("as_clr_expressions", id); + EmitOwnExpression(trap, id, node, children); + EmitOwnIsAsExpression(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.AsExpression": + trap.Tuple("as_expressions", id); + EmitOwnExpression(trap, id, node, children); + EmitOwnIsAsExpression(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.AssignDecrementStatement": + trap.Tuple("assign_decrement_statements", id); + EmitOwnStatement(trap, id, node, children); + EmitOwnAssignmentSingleField(trap, id, node, children); + EmitOwnAssignmentBinary(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.AssignDivideStatement": + trap.Tuple("assign_divide_statements", id); + EmitOwnStatement(trap, id, node, children); + EmitOwnAssignmentSingleField(trap, id, node, children); + EmitOwnAssignmentBinary(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.AssignEqualStatement": + trap.Tuple("assign_equal_statements", id); + EmitOwnStatement(trap, id, node, children); + EmitOwnAssignmentSingleField(trap, id, node, children); + EmitOwnAssignmentBinary(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.AssignIncrementStatement": + trap.Tuple("assign_increment_statements", id); + EmitOwnStatement(trap, id, node, children); + EmitOwnAssignmentSingleField(trap, id, node, children); + EmitOwnAssignmentBinary(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.AssignMultipleFieldStatement": + trap.Tuple("assign_multiple_field_statements", id); + EmitOwnStatement(trap, id, node, children); + EmitOwnAssignMultipleFieldStatement(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.AssignMultiplyStatement": + trap.Tuple("assign_multiply_statements", id); + EmitOwnStatement(trap, id, node, children); + EmitOwnAssignmentSingleField(trap, id, node, children); + EmitOwnAssignmentBinary(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.AssignPostDecrementStatement": + trap.Tuple("assign_post_decrement_statements", id); + EmitOwnStatement(trap, id, node, children); + EmitOwnAssignmentSingleField(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.AssignPostIncrementStatement": + trap.Tuple("assign_post_increment_statements", id); + EmitOwnStatement(trap, id, node, children); + EmitOwnAssignmentSingleField(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.AssignPreDecrementStatement": + trap.Tuple("assign_pre_decrement_statements", id); + EmitOwnStatement(trap, id, node, children); + EmitOwnAssignmentSingleField(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.AssignPreIncrementStatement": + trap.Tuple("assign_pre_increment_statements", id); + EmitOwnStatement(trap, id, node, children); + EmitOwnAssignmentSingleField(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.AssignmentEventHandlerClr": + trap.Tuple("assignment_event_handler_clrs", id); + EmitOwnStatement(trap, id, node, children); + EmitOwnAssignmentSingleField(trap, id, node, children); + EmitOwnAssignmentEventHandlerBase(trap, id, node, children); + EmitOwnAssignmentEventHandlerStatic(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.AssignmentEventHandlerInstance": + trap.Tuple("assignment_event_handler_instances", id); + EmitOwnStatement(trap, id, node, children); + EmitOwnAssignmentSingleField(trap, id, node, children); + EmitOwnAssignmentEventHandlerBase(trap, id, node, children); + EmitOwnAssignmentEventHandlerInstance(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.AssignmentEventHandlerStatic": + trap.Tuple("assignment_event_handler_static_internals", id); + EmitOwnStatement(trap, id, node, children); + EmitOwnAssignmentSingleField(trap, id, node, children); + EmitOwnAssignmentEventHandlerBase(trap, id, node, children); + EmitOwnAssignmentEventHandlerStatic(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.Attribute": + trap.Tuple("attributes", id); + EmitOwnAttribute(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.AttributeExpression": + trap.Tuple("attribute_expressions", id); + EmitOwnAttributeExpression(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.AttributeList": + trap.Tuple("attribute_lists", id); + EmitOwnAttributeList(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.AvgAggregateSelection": + trap.Tuple("avg_aggregate_selections", id); + EmitOwnSelectionField(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.BooleanAttributeLiteral": + trap.Tuple("boolean_attribute_literals", id); + EmitOwnDefaultTypeAttributeLiteral(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.BooleanLiteralExpression": + trap.Tuple("boolean_literal_expressions", id); + EmitOwnExpression(trap, id, node, children); + EmitOwnDefaultTypeLiteralExpression(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.BooleanType": + trap.Tuple("boolean_types", id); + EmitOwnXppType(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.BreakStatement": + trap.Tuple("break_statements", id); + EmitOwnStatement(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.BreakpointStatement": + trap.Tuple("breakpoint_statements", id); + EmitOwnStatement(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.CaseDefault": + trap.Tuple("case_defaults", id); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.CaseValues": + trap.Tuple("case_values", id); + EmitOwnCaseValues(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.CatchAllValues": + trap.Tuple("catch_all_values", id); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.CatchExpression": + trap.Tuple("catch_expressions", id); + EmitOwnCatchExpression(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.CatchUpdateConflict": + trap.Tuple("catch_update_conflicts", id); + EmitOwnCatchUpdateConflict(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.ChangeCompanyStatement": + trap.Tuple("change_company_statements", id); + EmitOwnStatement(trap, id, node, children); + EmitOwnChangeStatement(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.Class": + trap.Tuple("classes", id); + EmitOwnCompilationUnit(trap, id, node, children); + EmitOwnModelElement(trap, id, node, children); + EmitOwnClassOrInterface(trap, id, node, children); + EmitOwnClass(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.ClassAccessModifier": + trap.Tuple("class_access_modifiers", id); + EmitOwnClassAccessModifier(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.ClrEnumerationLiteralExpression": + trap.Tuple("clr_enumeration_literal_expressions", id); + EmitOwnExpression(trap, id, node, children); + EmitOwnClrEnumerationLiteralExpression(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.ClrType": + trap.Tuple("clr_types", id); + EmitOwnXppType(trap, id, node, children); + EmitOwnGenericXppType(trap, id, node, children); + EmitOwnClrType(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.CompoundStatement": + trap.Tuple("compound_statements", id); + EmitOwnStatement(trap, id, node, children); + EmitOwnCompoundStatement(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.ConditionalExpression": + trap.Tuple("conditional_expressions", id); + EmitOwnExpression(trap, id, node, children); + EmitOwnConditionalExpression(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.ContainerAttributeLiteral": + trap.Tuple("container_attribute_literals", id); + EmitOwnContainerAttributeLiteral(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.ContainerLiteralExpression": + trap.Tuple("container_literal_expressions", id); + EmitOwnExpression(trap, id, node, children); + EmitOwnContainerLiteralExpression(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.ContainerType": + trap.Tuple("container_types", id); + EmitOwnXppType(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.ContinueStatement": + trap.Tuple("continue_statements", id); + EmitOwnStatement(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.CountAggregateSelection": + trap.Tuple("count_aggregate_selections", id); + EmitOwnSelectionField(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.CrossCompanyAll": + trap.Tuple("cross_company_alls", id); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.CrossCompanyContainer": + trap.Tuple("cross_company_containers", id); + EmitOwnCrossCompanyContainer(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.DateAttributeLiteral": + trap.Tuple("date_attribute_literals", id); + EmitOwnDefaultTypeAttributeLiteral(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.DateLiteralExpression": + trap.Tuple("date_literal_expressions", id); + EmitOwnExpression(trap, id, node, children); + EmitOwnDefaultTypeLiteralExpression(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.DateTimeAttributeLiteral": + trap.Tuple("date_time_attribute_literals", id); + EmitOwnDefaultTypeAttributeLiteral(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.DateTimeLiteralExpression": + trap.Tuple("date_time_literal_expressions", id); + EmitOwnExpression(trap, id, node, children); + EmitOwnDefaultTypeLiteralExpression(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.DateTimeType": + trap.Tuple("date_time_types", id); + EmitOwnXppType(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.DateType": + trap.Tuple("date_types", id); + EmitOwnXppType(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.DblAttributeLiteral": + trap.Tuple("dbl_attribute_literals", id); + EmitOwnDefaultTypeAttributeLiteral(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.DblType": + trap.Tuple("dbl_types", id); + EmitOwnXppType(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.Delegate": + trap.Tuple("delegates", id); + EmitOwnCompilationUnit(trap, id, node, children); + EmitOwnMethodOrDelegate(trap, id, node, children); + EmitOwnDelegate(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.DeleteStatement": + trap.Tuple("delete_statements", id); + EmitOwnStatement(trap, id, node, children); + EmitOwnDeleteStatement(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.DivideExpression": + trap.Tuple("divide_expressions", id); + EmitOwnExpression(trap, id, node, children); + EmitOwnBinaryExpression(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.DoWhileStatement": + trap.Tuple("do_while_statements", id); + EmitOwnStatement(trap, id, node, children); + EmitOwnDoWhileStatement(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.EmptyExpression": + trap.Tuple("empty_expressions", id); + EmitOwnExpression(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.EmptyStatement": + trap.Tuple("empty_statements", id); + EmitOwnStatement(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.EnumAttributeLiteral": + trap.Tuple("enum_attribute_literals", id); + EmitOwnEnumAttributeLiteral(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.EnumerationLiteralExpression": + trap.Tuple("enumeration_literal_expressions", id); + EmitOwnExpression(trap, id, node, children); + EmitOwnEnumerationLiteralExpression(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.EnumerationType": + trap.Tuple("enumeration_types", id); + EmitOwnXppType(trap, id, node, children); + EmitOwnEnumerationType(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.EqualExpression": + trap.Tuple("equal_expressions", id); + EmitOwnExpression(trap, id, node, children); + EmitOwnBinaryExpression(trap, id, node, children); + EmitOwnRelationalExpression(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.ExplicitSelection": + trap.Tuple("explicit_selections", id); + EmitOwnExplicitSelection(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.ExpressionCompilationUnit": + trap.Tuple("expression_compilation_units", id); + EmitOwnCompilationUnit(trap, id, node, children); + EmitOwnExpressionCompilationUnit(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.ExpressionQualifier": + trap.Tuple("expression_qualifiers", id); + EmitOwnExpressionQualifier(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.ExpressionStatement": + trap.Tuple("expression_statements", id); + EmitOwnStatement(trap, id, node, children); + EmitOwnExpressionStatement(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.FieldAssignment": + trap.Tuple("field_assignments", id); + EmitOwnFieldAssignment(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.FieldDeclaration": + trap.Tuple("field_declaration_internals", id); + EmitOwnCompilationUnit(trap, id, node, children); + EmitOwnDeclaration(trap, id, node, children); + EmitOwnFieldDeclaration(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.FieldExpression": + trap.Tuple("field_expression_internals", id); + EmitOwnExpression(trap, id, node, children); + EmitOwnFieldExpression(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.FieldSelection": + trap.Tuple("field_selections", id); + EmitOwnSelectionField(trap, id, node, children); + EmitOwnFieldSelection(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.FindStatement": + trap.Tuple("find_statements", id); + EmitOwnStatement(trap, id, node, children); + EmitOwnFindStatement(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.FlushStatement": + trap.Tuple("flush_statements", id); + EmitOwnStatement(trap, id, node, children); + EmitOwnFlushStatement(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.ForDeclarationAssign": + trap.Tuple("for_declaration_assigns", id); + EmitOwnForAssign(trap, id, node, children); + EmitOwnForDeclarationAssign(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.ForFieldAssign": + trap.Tuple("for_field_assigns", id); + EmitOwnForAssign(trap, id, node, children); + EmitOwnForExpressionAssign(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.ForFieldDecrementAssign": + trap.Tuple("for_field_decrement_assigns", id); + EmitOwnForAssign(trap, id, node, children); + EmitOwnForExpressionAssign(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.ForFieldIncrementAssign": + trap.Tuple("for_field_increment_assigns", id); + EmitOwnForAssign(trap, id, node, children); + EmitOwnForExpressionAssign(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.ForFieldPostDecrement": + trap.Tuple("for_field_post_decrements", id); + EmitOwnForAssign(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.ForFieldPostIncrement": + trap.Tuple("for_field_post_increments", id); + EmitOwnForAssign(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.ForFieldPreDecrement": + trap.Tuple("for_field_pre_decrements", id); + EmitOwnForAssign(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.ForFieldPreIncrement": + trap.Tuple("for_field_pre_increments", id); + EmitOwnForAssign(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.ForStatement": + trap.Tuple("for_statements", id); + EmitOwnStatement(trap, id, node, children); + EmitOwnForStatement(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.FormControl": + trap.Tuple("form_controls", id); + EmitOwnCompilationUnit(trap, id, node, children); + EmitOwnModelElement(trap, id, node, children); + EmitOwnFormNestedElement(trap, id, node, children); + EmitOwnFormControl(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.FormDataField": + trap.Tuple("form_data_fields", id); + EmitOwnCompilationUnit(trap, id, node, children); + EmitOwnModelElement(trap, id, node, children); + EmitOwnFormNestedElement(trap, id, node, children); + EmitOwnFormDataField(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.FormDataSource": + trap.Tuple("form_data_sources", id); + EmitOwnCompilationUnit(trap, id, node, children); + EmitOwnModelElement(trap, id, node, children); + EmitOwnFormNestedElement(trap, id, node, children); + EmitOwnFormDataSource(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.FormElementType": + trap.Tuple("form_element_types", id); + EmitOwnXppType(trap, id, node, children); + EmitOwnGenericXppType(trap, id, node, children); + EmitOwnNamedType(trap, id, node, children); + EmitOwnFormElementType(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.FormModelElement": + trap.Tuple("form_model_elements", id); + EmitOwnCompilationUnit(trap, id, node, children); + EmitOwnModelElement(trap, id, node, children); + EmitOwnFormModelElement(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.FunctionCall": + trap.Tuple("function_calls", id); + EmitOwnExpression(trap, id, node, children); + EmitOwnEvaluation(trap, id, node, children); + EmitOwnGenericEvaluation(trap, id, node, children); + EmitOwnFunctionCall(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.FunctionDeclaration": + trap.Tuple("function_declarations", id); + EmitOwnCompilationUnit(trap, id, node, children); + EmitOwnDeclaration(trap, id, node, children); + EmitOwnFunctionDeclaration(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.GlobalOrderElement": + trap.Tuple("global_order_elements", id); + EmitOwnOrderElement(trap, id, node, children); + EmitOwnGlobalOrderElement(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.GreaterThanExpression": + trap.Tuple("greater_than_expressions", id); + EmitOwnExpression(trap, id, node, children); + EmitOwnBinaryExpression(trap, id, node, children); + EmitOwnRelationalExpression(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.GreaterThanOrEqualExpression": + trap.Tuple("greater_than_or_equal_expressions", id); + EmitOwnExpression(trap, id, node, children); + EmitOwnBinaryExpression(trap, id, node, children); + EmitOwnRelationalExpression(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.GuidAttributeLiteral": + trap.Tuple("guid_attribute_literals", id); + EmitOwnDefaultTypeAttributeLiteral(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.GuidType": + trap.Tuple("guid_types", id); + EmitOwnXppType(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.IfStatement": + trap.Tuple("if_statements", id); + EmitOwnStatement(trap, id, node, children); + EmitOwnIfStatement(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.IfThenElseStatement": + trap.Tuple("if_then_else_statements", id); + EmitOwnStatement(trap, id, node, children); + EmitOwnIfThenElseStatement(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.ImplicitSelection": + trap.Tuple("implicit_selections", id); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.InExpression": + trap.Tuple("in_expressions", id); + EmitOwnExpression(trap, id, node, children); + EmitOwnBinaryExpression(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.InsertFieldSpecification": + trap.Tuple("insert_field_specifications", id); + EmitOwnInsertFieldSpecification(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.InsertStatement": + trap.Tuple("insert_statements", id); + EmitOwnStatement(trap, id, node, children); + EmitOwnInsertStatement(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.Int64AttributeLiteral": + trap.Tuple("int64_attribute_literals", id); + EmitOwnDefaultTypeAttributeLiteral(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.Int64LiteralExpression": + trap.Tuple("int64_literal_expressions", id); + EmitOwnExpression(trap, id, node, children); + EmitOwnDefaultTypeLiteralExpression(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.Int64Type": + trap.Tuple("int64_types", id); + EmitOwnXppType(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.IntAttributeLiteral": + trap.Tuple("int_attribute_literals", id); + EmitOwnDefaultTypeAttributeLiteral(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.IntLiteralExpression": + trap.Tuple("int_literal_expressions", id); + EmitOwnExpression(trap, id, node, children); + EmitOwnDefaultTypeLiteralExpression(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.IntType": + trap.Tuple("int_types", id); + EmitOwnXppType(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.IntegerDivideExpression": + trap.Tuple("integer_divide_expressions", id); + EmitOwnExpression(trap, id, node, children); + EmitOwnBinaryExpression(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.Interface": + trap.Tuple("interfaces", id); + EmitOwnCompilationUnit(trap, id, node, children); + EmitOwnModelElement(trap, id, node, children); + EmitOwnClassOrInterface(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.Intrinsic": + trap.Tuple("intrinsics", id); + EmitOwnExpression(trap, id, node, children); + EmitOwnIntrinsic(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.IntrinsicAttributeLiteral": + trap.Tuple("intrinsic_attribute_literals", id); + EmitOwnIntrinsicAttributeLiteral(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.IsClrExpression": + trap.Tuple("is_clr_expressions", id); + EmitOwnExpression(trap, id, node, children); + EmitOwnIsAsExpression(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.IsExpression": + trap.Tuple("is_expressions", id); + EmitOwnExpression(trap, id, node, children); + EmitOwnIsAsExpression(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.JoinSpecification": + trap.Tuple("join_specifications", id); + EmitOwnJoinSpecification(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.LessThanExpression": + trap.Tuple("less_than_expressions", id); + EmitOwnExpression(trap, id, node, children); + EmitOwnBinaryExpression(trap, id, node, children); + EmitOwnRelationalExpression(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.LessThanOrEqualExpression": + trap.Tuple("less_than_or_equal_expressions", id); + EmitOwnExpression(trap, id, node, children); + EmitOwnBinaryExpression(trap, id, node, children); + EmitOwnRelationalExpression(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.LikeExpression": + trap.Tuple("like_expressions", id); + EmitOwnExpression(trap, id, node, children); + EmitOwnBinaryExpression(trap, id, node, children); + EmitOwnRelationalExpression(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.LocalDeclarationsStatement": + trap.Tuple("local_declarations_statements", id); + EmitOwnStatement(trap, id, node, children); + EmitOwnLocalDeclarationsStatement(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.MaxAggregateSelection": + trap.Tuple("max_aggregate_selections", id); + EmitOwnSelectionField(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.Method": + trap.Tuple("methods", id); + EmitOwnCompilationUnit(trap, id, node, children); + EmitOwnMethodOrDelegate(trap, id, node, children); + EmitOwnMethod(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.MinAggregateSelection": + trap.Tuple("min_aggregate_selections", id); + EmitOwnSelectionField(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.ModExpression": + trap.Tuple("mod_expressions", id); + EmitOwnExpression(trap, id, node, children); + EmitOwnBinaryExpression(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.Modifier": + trap.Tuple("modifiers", id); + EmitOwnModifier(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.MoveCursorStatement": + trap.Tuple("move_cursor_statements", id); + EmitOwnStatement(trap, id, node, children); + EmitOwnMoveCursorStatement(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.MultiplyExpression": + trap.Tuple("multiply_expressions", id); + EmitOwnExpression(trap, id, node, children); + EmitOwnBinaryExpression(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.NamedFieldReference": + trap.Tuple("named_field_references", id); + EmitOwnTableFieldReference(trap, id, node, children); + EmitOwnNamedFieldReference(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.NamedType": + trap.Tuple("named_type_internals", id); + EmitOwnXppType(trap, id, node, children); + EmitOwnGenericXppType(trap, id, node, children); + EmitOwnNamedType(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.NewCall": + trap.Tuple("new_calls", id); + EmitOwnExpression(trap, id, node, children); + EmitOwnEvaluation(trap, id, node, children); + EmitOwnNewCall(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.NewClrArrayExpression": + trap.Tuple("new_clr_array_expressions", id); + EmitOwnExpression(trap, id, node, children); + EmitOwnNewClrArrayExpression(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.NewClrCall": + trap.Tuple("new_clr_calls", id); + EmitOwnExpression(trap, id, node, children); + EmitOwnEvaluation(trap, id, node, children); + EmitOwnGenericEvaluation(trap, id, node, children); + EmitOwnNewClrCall(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.NextExpression": + trap.Tuple("next_expressions", id); + EmitOwnExpression(trap, id, node, children); + EmitOwnEvaluation(trap, id, node, children); + EmitOwnNextExpression(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.NotEqualExpression": + trap.Tuple("not_equal_expressions", id); + EmitOwnExpression(trap, id, node, children); + EmitOwnBinaryExpression(trap, id, node, children); + EmitOwnRelationalExpression(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.NotExpression": + trap.Tuple("not_expressions", id); + EmitOwnExpression(trap, id, node, children); + EmitOwnUnaryExpression(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.NullLiteralExpression": + trap.Tuple("null_literal_expressions", id); + EmitOwnExpression(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.NumberedFieldReference": + trap.Tuple("numbered_field_references", id); + EmitOwnTableFieldReference(trap, id, node, children); + EmitOwnNumberedFieldReference(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.OrExpression": + trap.Tuple("or_expressions", id); + EmitOwnExpression(trap, id, node, children); + EmitOwnBinaryExpression(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.ParameterDeclaration": + trap.Tuple("parameter_declarations", id); + EmitOwnCompilationUnit(trap, id, node, children); + EmitOwnDeclaration(trap, id, node, children); + EmitOwnVariableDeclaration(trap, id, node, children); + EmitOwnParameterDeclaration(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.PhysicalAndExpression": + trap.Tuple("physical_and_expressions", id); + EmitOwnExpression(trap, id, node, children); + EmitOwnBinaryExpression(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.PhysicalNotExpression": + trap.Tuple("physical_not_expressions", id); + EmitOwnExpression(trap, id, node, children); + EmitOwnUnaryExpression(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.PhysicalOrExpression": + trap.Tuple("physical_or_expressions", id); + EmitOwnExpression(trap, id, node, children); + EmitOwnBinaryExpression(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.PhysicalXorExpression": + trap.Tuple("physical_xor_expressions", id); + EmitOwnExpression(trap, id, node, children); + EmitOwnBinaryExpression(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.Placeholder": + trap.Tuple("placeholders", id); + EmitOwnExpression(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.PrintStatement": + trap.Tuple("print_statements", id); + EmitOwnStatement(trap, id, node, children); + EmitOwnPrintStatement(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.ProvidedType": + trap.Tuple("provided_types", id); + EmitOwnXppType(trap, id, node, children); + EmitOwnProvidedType(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.ProvidedTypeStaticCall": + trap.Tuple("provided_type_static_calls", id); + EmitOwnExpression(trap, id, node, children); + EmitOwnEvaluation(trap, id, node, children); + EmitOwnProvidedTypeStaticCall(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.QualifiedCall": + trap.Tuple("qualified_calls", id); + EmitOwnExpression(trap, id, node, children); + EmitOwnEvaluation(trap, id, node, children); + EmitOwnGenericEvaluation(trap, id, node, children); + EmitOwnQualifiedCall(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.QualifiedField": + trap.Tuple("qualified_fields", id); + EmitOwnFieldSpecification(trap, id, node, children); + EmitOwnQualifiedField(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.QualifiedInstanceName": + trap.Tuple("qualified_instance_names", id); + EmitOwnQualifiedInstanceName(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.QualifiedNumberedField": + trap.Tuple("qualified_numbered_fields", id); + EmitOwnFieldSpecification(trap, id, node, children); + EmitOwnQualifiedNumberedField(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.QualifiedStaticCall": + trap.Tuple("qualified_static_calls", id); + EmitOwnExpression(trap, id, node, children); + EmitOwnEvaluation(trap, id, node, children); + EmitOwnGenericEvaluation(trap, id, node, children); + EmitOwnQualifiedStaticCall(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.QualifiedStaticField": + trap.Tuple("qualified_static_fields", id); + EmitOwnFieldSpecification(trap, id, node, children); + EmitOwnQualifiedStaticField(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.QualifiedStaticFieldExpression": + trap.Tuple("qualified_static_field_expressions", id); + EmitOwnExpression(trap, id, node, children); + EmitOwnFieldExpression(trap, id, node, children); + EmitOwnQualifiedStaticFieldExpression(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.Query": + trap.Tuple("queries", id); + EmitOwnQuery(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.QueryDataSource": + trap.Tuple("query_data_sources", id); + EmitOwnQueryDataSource(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.QueryDataSourceHaving": + trap.Tuple("query_data_source_havings", id); + EmitOwnQueryDataSourceHaving(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.QueryDataSourceRange": + trap.Tuple("query_data_source_ranges", id); + EmitOwnQueryDataSourceRange(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.QueryDataSourceRelation": + trap.Tuple("query_data_source_relations", id); + EmitOwnQueryDataSourceRelation(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.QueryModelElement": + trap.Tuple("query_model_elements", id); + EmitOwnCompilationUnit(trap, id, node, children); + EmitOwnModelElement(trap, id, node, children); + EmitOwnQueryModelElement(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.RealLiteralExpression": + trap.Tuple("real_literal_expressions", id); + EmitOwnExpression(trap, id, node, children); + EmitOwnDefaultTypeLiteralExpression(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.RetryStatement": + trap.Tuple("retry_statements", id); + EmitOwnStatement(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.ReturnStatement": + trap.Tuple("return_statements", id); + EmitOwnStatement(trap, id, node, children); + EmitOwnReturnStatement(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.SearchStatement": + trap.Tuple("search_statements", id); + EmitOwnStatement(trap, id, node, children); + EmitOwnSearchStatement(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.ShiftLeftExpression": + trap.Tuple("shift_left_expressions", id); + EmitOwnExpression(trap, id, node, children); + EmitOwnBinaryExpression(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.ShiftRightExpression": + trap.Tuple("shift_right_expressions", id); + EmitOwnExpression(trap, id, node, children); + EmitOwnBinaryExpression(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.SimpleField": + trap.Tuple("simple_fields", id); + EmitOwnFieldSpecification(trap, id, node, children); + EmitOwnSimpleField(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.SimpleInstanceName": + trap.Tuple("simple_instance_names", id); + EmitOwnSimpleInstanceName(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.SimpleOrderElement": + trap.Tuple("simple_order_elements", id); + EmitOwnOrderElement(trap, id, node, children); + EmitOwnSimpleOrderElement(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.SimpleQualifier": + trap.Tuple("simple_qualifier_internals", id); + EmitOwnSimpleQualifier(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.StaticField": + trap.Tuple("static_fields", id); + EmitOwnFieldSpecification(trap, id, node, children); + EmitOwnStaticField(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.StaticMethodCall": + trap.Tuple("static_method_calls", id); + EmitOwnExpression(trap, id, node, children); + EmitOwnEvaluation(trap, id, node, children); + EmitOwnGenericEvaluation(trap, id, node, children); + EmitOwnStaticMethodCall(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.StaticQualifier": + trap.Tuple("static_qualifiers", id); + EmitOwnSimpleQualifier(trap, id, node, children); + EmitOwnStaticQualifier(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.StringAttributeLiteral": + trap.Tuple("string_attribute_literals", id); + EmitOwnDefaultTypeAttributeLiteral(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.StringLengthType": + trap.Tuple("string_length_types", id); + EmitOwnXppType(trap, id, node, children); + EmitOwnStringLengthType(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.StringLiteralExpression": + trap.Tuple("string_literal_expressions", id); + EmitOwnExpression(trap, id, node, children); + EmitOwnDefaultTypeLiteralExpression(trap, id, node, children); + EmitOwnStringLiteralExpression(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.StringType": + trap.Tuple("string_type_internals", id); + EmitOwnXppType(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.SubtractExpression": + trap.Tuple("subtract_expressions", id); + EmitOwnExpression(trap, id, node, children); + EmitOwnBinaryExpression(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.SumAggregateSelection": + trap.Tuple("sum_aggregate_selections", id); + EmitOwnSelectionField(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.SuperCall": + trap.Tuple("super_calls", id); + EmitOwnExpression(trap, id, node, children); + EmitOwnEvaluation(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.SwitchCase": + trap.Tuple("switch_cases", id); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.SwitchStatement": + trap.Tuple("switch_statements", id); + EmitOwnStatement(trap, id, node, children); + EmitOwnSwitchStatement(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.Table": + trap.Tuple("tables", id); + EmitOwnCompilationUnit(trap, id, node, children); + EmitOwnModelElement(trap, id, node, children); + EmitOwnTable(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.TableFieldDeclaration": + trap.Tuple("table_field_declarations", id); + EmitOwnCompilationUnit(trap, id, node, children); + EmitOwnDeclaration(trap, id, node, children); + EmitOwnFieldDeclaration(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.TableLookupExpression": + trap.Tuple("table_lookup_expressions", id); + EmitOwnExpression(trap, id, node, children); + EmitOwnTableLookupExpression(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.ThrowStatement": + trap.Tuple("throw_statements", id); + EmitOwnStatement(trap, id, node, children); + EmitOwnThrowStatement(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.TryStatement": + trap.Tuple("try_statements", id); + EmitOwnStatement(trap, id, node, children); + EmitOwnTryStatement(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.TtsAbortStatement": + trap.Tuple("tts_abort_statements", id); + EmitOwnStatement(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.TtsBeginStatement": + trap.Tuple("tts_begin_statements", id); + EmitOwnStatement(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.TtsEndStatement": + trap.Tuple("tts_end_statements", id); + EmitOwnStatement(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.UnaryMinusExpression": + trap.Tuple("unary_minus_expressions", id); + EmitOwnExpression(trap, id, node, children); + EmitOwnUnaryExpression(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.UncheckedStatement": + trap.Tuple("unchecked_statements", id); + EmitOwnStatement(trap, id, node, children); + EmitOwnUncheckedStatement(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.UpdateStatement": + trap.Tuple("update_statements", id); + EmitOwnStatement(trap, id, node, children); + EmitOwnUpdateStatement(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.UsingStatement": + trap.Tuple("using_statements", id); + EmitOwnStatement(trap, id, node, children); + EmitOwnUsingStatement(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.ValidTimeStateDate": + trap.Tuple("valid_time_state_dates", id); + EmitOwnValidTimeStateDate(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.ValidTimeStateRange": + trap.Tuple("valid_time_state_ranges", id); + EmitOwnValidTimeStateRange(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.VarType": + trap.Tuple("var_types", id); + EmitOwnXppType(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.VariableDeclaration": + trap.Tuple("variable_declaration_internals", id); + EmitOwnCompilationUnit(trap, id, node, children); + EmitOwnDeclaration(trap, id, node, children); + EmitOwnVariableDeclaration(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.VoidType": + trap.Tuple("void_types", id); + EmitOwnXppType(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.WhileStatement": + trap.Tuple("while_statements", id); + EmitOwnStatement(trap, id, node, children); + EmitOwnWhileStatement(trap, id, node, children); + return true; + case "Microsoft.Dynamics.AX.Metadata.XppCompiler.XppTypeCompilationUnit": + trap.Tuple("xpp_type_compilation_units", id); + EmitOwnCompilationUnit(trap, id, node, children); + EmitOwnXppTypeCompilationUnit(trap, id, node, children); + return true; + default: + return false; + } + } +} diff --git a/xpp/extractor/Xpp.Extraction/ITrapFile.cs b/xpp/extractor/Xpp.Extraction/ITrapFile.cs new file mode 100644 index 000000000000..783f51c35a1a --- /dev/null +++ b/xpp/extractor/Xpp.Extraction/ITrapFile.cs @@ -0,0 +1,23 @@ +namespace Xpp.Extraction; + +/// +/// Sink for TRAP tuples. The generated AstTrapEmitter writes through this interface, so +/// tests can capture tuples without touching the filesystem. +/// +public interface ITrapFile +{ + /// Allocates a label with no stable identity of its own. + Label FreshLabel(); + + /// + /// The label for an AST node, allocated on first use so repeated references to the same node + /// share one entity. + /// + Label Label(object node); + + /// + /// Writes one tuple. Arguments may be , , + /// or . + /// + void Tuple(string relation, params object[] arguments); +} diff --git a/xpp/extractor/Xpp.Extraction/Label.cs b/xpp/extractor/Xpp.Extraction/Label.cs new file mode 100644 index 000000000000..f7013a165b8e --- /dev/null +++ b/xpp/extractor/Xpp.Extraction/Label.cs @@ -0,0 +1,9 @@ +namespace Xpp.Extraction; + +/// +/// A TRAP label: the identity of one entity within a single TRAP file. +/// +public readonly record struct Label(int Value) +{ + public override string ToString() => "#" + Value; +} diff --git a/xpp/extractor/Xpp.Extraction/NullMetadataProvider.cs b/xpp/extractor/Xpp.Extraction/NullMetadataProvider.cs new file mode 100644 index 000000000000..7463d4df4606 --- /dev/null +++ b/xpp/extractor/Xpp.Extraction/NullMetadataProvider.cs @@ -0,0 +1,44 @@ +using System.Collections; +using System.Reflection; +using Microsoft.Dynamics.AX.Framework.Xlnt.XppParser; + +namespace Xpp.Extraction; + +/// +/// An that knows about nothing. +/// +/// +/// Parsing method bodies needs no metadata at all, but a class or interface header does: the +/// parser looks up the base type named by `extends`. Supplying an empty provider lets the header +/// parse and leaves the base type unresolved, which is the right trade for an extractor that +/// records source structure rather than resolved types. +/// +/// The interface has more than eighty members, nearly all of which would be an empty default, so +/// it is implemented with rather than by hand. +/// +public class NullMetadataProvider : DispatchProxy +{ + public static IXppcMetadataProvider Create() => + Create()!; + + protected override object? Invoke(MethodInfo? targetMethod, object?[]? args) + { + var returnType = targetMethod?.ReturnType; + if (returnType is null || returnType == typeof(void)) + return null; + + // Callers iterate returned sequences directly, so an empty one is safer than null. + if (returnType != typeof(string) && + typeof(IEnumerable).IsAssignableFrom(returnType)) + { + var element = returnType.IsGenericType + ? returnType.GetGenericArguments().FirstOrDefault() ?? typeof(object) + : typeof(object); + + if (returnType.IsAssignableFrom(element.MakeArrayType())) + return Array.CreateInstance(element, 0); + } + + return returnType.IsValueType ? Activator.CreateInstance(returnType) : null; + } +} diff --git a/xpp/extractor/Xpp.Extraction/TrapFile.cs b/xpp/extractor/Xpp.Extraction/TrapFile.cs new file mode 100644 index 000000000000..a5bc05ce6951 --- /dev/null +++ b/xpp/extractor/Xpp.Extraction/TrapFile.cs @@ -0,0 +1,69 @@ +using System.Globalization; +using System.Runtime.CompilerServices; +using System.Text; + +namespace Xpp.Extraction; + +/// +/// Writes TRAP tuples to a . +/// +public sealed class TrapFile(TextWriter writer) : ITrapFile +{ + // Reference equality: two distinct AST nodes are distinct entities even if they compare + // equal, and the compiler's AST nodes do not override Equals anyway. + private readonly Dictionary labels = new(ReferenceEqualityComparer.Instance); + + private int next; + + public Label FreshLabel() + { + var label = new Label(++next); + writer.Write(label); + writer.WriteLine("=*"); + return label; + } + + public Label Label(object node) + { + if (labels.TryGetValue(node, out var existing)) + return existing; + + var label = FreshLabel(); + labels[node] = label; + return label; + } + + public void Tuple(string relation, params object[] arguments) + { + var line = new StringBuilder(relation.Length + 16 * arguments.Length); + line.Append(relation).Append('('); + for (var i = 0; i < arguments.Length; i++) + { + if (i > 0) + line.Append(','); + Append(line, arguments[i]); + } + + line.Append(')'); + writer.WriteLine(line.ToString()); + } + + private static void Append(StringBuilder line, object argument) + { + switch (argument) + { + case Label label: + line.Append(label); + break; + case string text: + line.Append('"').Append(text.Replace("\"", "\"\"")).Append('"'); + break; + case bool flag: + line.Append(flag ? '1' : '0'); + break; + default: + line.Append(Convert.ToString(argument, CultureInfo.InvariantCulture)); + break; + } + } +} diff --git a/xpp/extractor/Xpp.Extraction/Xpp.Extraction.csproj b/xpp/extractor/Xpp.Extraction/Xpp.Extraction.csproj new file mode 100644 index 000000000000..f6e31f028c61 --- /dev/null +++ b/xpp/extractor/Xpp.Extraction/Xpp.Extraction.csproj @@ -0,0 +1,41 @@ + + + + net8.0 + enable + enable + Xpp.Extraction + Xpp.Extraction + + + + + $(XPP_COMPILER_PACKAGE) + + + + + + + + + $(XppCompilerPackage)/Microsoft.Dynamics.AX.Framework.Xlnt.XppCore.dll + false + + + $(XppCompilerPackage)/Microsoft.Dynamics.AX.Framework.Xlnt.XppParser.dll + false + + + + $(XppCompilerPackage)/Microsoft.Dynamics.AX.Metadata.Core.dll + false + + + + diff --git a/xpp/extractor/Xpp.Extraction/XppSourceFile.cs b/xpp/extractor/Xpp.Extraction/XppSourceFile.cs new file mode 100644 index 000000000000..077a0c5850d7 --- /dev/null +++ b/xpp/extractor/Xpp.Extraction/XppSourceFile.cs @@ -0,0 +1,101 @@ +using System.Xml; +using System.Xml.Linq; + +namespace Xpp.Extraction; + +/// One block of X++ source embedded in a metadata XML file. +/// Method name, or null for a class declaration. +/// The X++ text. +/// +/// Zero-based line at which begins within the containing file, so the +/// parser can report positions relative to the file rather than the fragment. +/// +public sealed record XppSourceBlock(string? Name, string Source, int LineOffset); + +/// +/// Reads the X++ source embedded in a D365 F&O metadata object. +/// +/// +/// X++ is not stored as standalone files. Each object is an XML document — `AxClass/Foo.xml`, +/// `AxTable/Bar.xml` and so on — whose `SourceCode` element holds the declaration and each +/// method body in CDATA sections. +/// +public static class XppSourceFile +{ + /// Metadata object directories that can contain X++ source. + private static readonly string[] SourceBearingDirectories = + [ + "AxClass", "AxTable", "AxForm", "AxQuery", "AxView", "AxMap", "AxDataEntityView", + "AxTableExtension", "AxFormExtension", "AxClassExtension", "AxViewExtension", + ]; + + /// + /// True if looks like an X++ metadata object rather than an + /// unrelated XML file. + /// + public static bool IsCandidate(string path) + { + if (!path.EndsWith(".xml", StringComparison.OrdinalIgnoreCase)) + return false; + + var directory = Path.GetFileName(Path.GetDirectoryName(path)); + return directory is not null && + SourceBearingDirectories.Contains(directory, StringComparer.OrdinalIgnoreCase); + } + + /// + /// Parses keeping line information, which the source blocks need in + /// order to report file-relative positions. + /// + public static XDocument Parse(string text) => XDocument.Parse(text, LoadOptions.SetLineInfo); + + /// The object's name, or null if the document is not a metadata object. + public static string? ObjectName(XDocument document) => + document.Root?.Element("Name")?.Value; + + /// + /// Every source block in the document, in file order. + /// + public static IEnumerable Blocks(XDocument document) + { + var sourceCode = document.Root?.Element("SourceCode"); + if (sourceCode is null) + yield break; + + var declaration = sourceCode.Element("Declaration"); + if (declaration is not null && !string.IsNullOrWhiteSpace(declaration.Value)) + yield return new XppSourceBlock(null, declaration.Value, LineOffsetOf(declaration)); + + var methods = sourceCode.Element("Methods"); + if (methods is null) + yield break; + + foreach (var method in methods.Elements("Method")) + { + var source = method.Element("Source"); + if (source is null || string.IsNullOrWhiteSpace(source.Value)) + continue; + + yield return new XppSourceBlock( + method.Element("Name")?.Value, source.Value, LineOffsetOf(source)); + } + } + + /// + /// The line offset to give the parser for the CDATA payload of . + /// + /// + /// This comes from the XML line information rather than from searching the raw text for the + /// payload. An XML parser normalises CRLF to LF inside element values, so on the + /// Windows-authored files that F&O produces the payload never matches the bytes on disk + /// and a search-based offset silently collapses to zero. + /// + /// The element's reported line is where <Source><![CDATA[ sits, and the + /// payload begins immediately after, so the offset is one less than that line. + /// + private static int LineOffsetOf(XElement element) + { + var info = (IXmlLineInfo)element; + return info.HasLineInfo() ? Math.Max(0, info.LineNumber - 1) : 0; + } +} diff --git a/xpp/extractor/Xpp.Extractor/Program.cs b/xpp/extractor/Xpp.Extractor/Program.cs new file mode 100644 index 000000000000..bf6c28ffb6e5 --- /dev/null +++ b/xpp/extractor/Xpp.Extractor/Program.cs @@ -0,0 +1,165 @@ +using Xpp.Extraction; + +// Extracts X++ metadata objects to TRAP. +// +// Xpp.Extractor [...] [--file-list ] [--trap ] +// +// Paths may be files or directories; directories are searched for metadata objects that can +// carry X++ source. When run by the CodeQL CLI the destinations come from the +// CODEQL_EXTRACTOR_XPP_* environment instead, and `--file-list` supplies the files to index. + +var paths = new List(); +var indexed = new List(); +string? trapPath = null; +string? fileList = null; + +for (var i = 0; i < args.Length; i++) +{ + switch (args[i]) + { + case "--trap" when i + 1 < args.Length: + trapPath = args[++i]; + break; + case "--file-list" when i + 1 < args.Length: + fileList = args[++i]; + break; + default: + paths.Add(args[i]); + break; + } +} + +if (fileList is not null) +{ + if (!File.Exists(fileList)) + { + Console.Error.WriteLine($"file list not found: {fileList}"); + return 2; + } + + // The extractor declares the .xml extension, so the CLI's list covers every XML file in + // the tree. Only the metadata objects that can carry X++ are ours to extract. + indexed.AddRange(File.ReadAllLines(fileList) + .Where(l => !string.IsNullOrWhiteSpace(l)) + .Where(XppSourceFile.IsCandidate)); +} + +if (paths.Count == 0 && indexed.Count == 0) +{ + Console.Error.WriteLine("usage: Xpp.Extractor [...] [--file-list ] [--trap ]"); + return 2; +} + +try +{ + CompilerPackageResolver.Install(); +} +catch (DirectoryNotFoundException e) +{ + Console.Error.WriteLine(e.Message); + return 2; +} + +var files = new List(indexed); +foreach (var path in paths) +{ + if (Directory.Exists(path)) + { + files.AddRange(Directory.EnumerateFiles(path, "*.xml", SearchOption.AllDirectories) + .Where(XppSourceFile.IsCandidate)); + } + else if (File.Exists(path)) + { + files.Add(path); + } + else + { + Console.Error.WriteLine($"no such path: {path}"); + } +} + +var layout = ExtractorLayout.FromEnvironment(); +var extractor = new Extractor(); + +var totalBlocks = 0; +var totalNodes = 0; +var totalUnsupported = 0; +var failed = 0; + +// One shared stream when the caller asked for a single TRAP file or stdout; otherwise the CLI +// expects one TRAP file per source file. +TextWriter? shared = trapPath is not null + ? new StreamWriter(File.Create(trapPath)) + : layout.TrapDirectory is null + ? Console.Out + : null; + +// Labels are only unique within a TRAP file, so a shared stream must also share one writer; +// a writer per input would restart at #1 and collide. +var sharedTrap = shared is null ? null : new TrapFile(shared); + +try +{ + foreach (var file in files.OrderBy(f => f, StringComparer.Ordinal)) + { + var output = shared; + var trap = sharedTrap; + if (output is null) + { + var destination = layout.TrapPathFor(file)!; + Directory.CreateDirectory(Path.GetDirectoryName(destination)!); + output = new StreamWriter(File.Create(destination)); + trap = new TrapFile(output); + } + + try + { + var result = extractor.Extract(file, trap!); + totalBlocks += result.Blocks; + totalNodes += result.Nodes; + totalUnsupported += result.Unsupported; + + foreach (var error in result.Errors) + { + failed++; + Console.Error.WriteLine($"{file}: {error}"); + } + } + finally + { + if (!ReferenceEquals(output, shared)) + output.Dispose(); + } + + CopyToSourceArchive(file, layout); + } +} +finally +{ + if (shared is not null && !ReferenceEquals(shared, Console.Out)) + shared.Dispose(); +} + +Console.Error.WriteLine( + $"extracted {files.Count} files, {totalBlocks} source blocks, {totalNodes} nodes " + + $"({totalUnsupported} unsupported, {failed} errors)"); + +return failed == 0 ? 0 : 1; + +// Alerts need the original file in order to display, so it is copied verbatim. +static void CopyToSourceArchive(string file, ExtractorLayout layout) +{ + var destination = layout.ArchivePathFor(file); + if (destination is null) + return; + + try + { + Directory.CreateDirectory(Path.GetDirectoryName(destination)!); + File.Copy(file, destination, overwrite: true); + } + catch (Exception e) + { + Console.Error.WriteLine($"{file}: could not archive source: {e.Message}"); + } +} diff --git a/xpp/extractor/Xpp.Extractor/Xpp.Extractor.csproj b/xpp/extractor/Xpp.Extractor/Xpp.Extractor.csproj new file mode 100644 index 000000000000..21e1f9304e38 --- /dev/null +++ b/xpp/extractor/Xpp.Extractor/Xpp.Extractor.csproj @@ -0,0 +1,16 @@ + + + + Exe + net8.0 + enable + enable + Xpp.Extractor + Xpp.Extractor + + + + + + + diff --git a/xpp/extractor/Xpp.SchemaGenerator/AstModel.cs b/xpp/extractor/Xpp.SchemaGenerator/AstModel.cs new file mode 100644 index 000000000000..6f38809db8f9 --- /dev/null +++ b/xpp/extractor/Xpp.SchemaGenerator/AstModel.cs @@ -0,0 +1,749 @@ +using System.Reflection; +using System.Text; + +namespace Xpp.SchemaGenerator; + +public enum PropertyKind +{ + /// A single owned AST child. + Child, + + /// An ordered collection of owned AST children. + ChildList, + + String, + StringList, + Boolean, + Int, + IntList, + + /// A CLR enum, recorded by member name. + Enum, + + /// A collection of CLR enums, recorded by member name. + EnumList, + + /// Deliberately not represented in the schema. + Skipped, +} + +public sealed record AstProperty( + string ClrName, + string SchemaName, + PropertyKind Kind, + string? TypeName, + string? SkipReason) +{ + /// + /// Explicit dbscheme table name, set when the derived name would clash with another + /// declaration. See . + /// + public string? TableName { get; init; } +} + +public sealed record AstType( + string Name, + string? BaseName, + bool IsAbstract, + IReadOnlyList Properties, + bool IsSynthetic = false, + /// + /// True for open generic CLR classes. They cannot be named in generated code, and a closed + /// instance's runtime name would not match a dispatch case, so they are treated as abstract. + /// + bool IsGeneric = false); + +/// +/// The X++ AST hierarchy, reflected out of the compiler package and classified into the shape +/// misc/codegen consumes. +/// +public sealed class AstModel +{ + /// + /// Back-references to the containing node. The schema models containment top-down, so these + /// would introduce cycles. + /// + private static readonly HashSet BackReferences = new(StringComparer.Ordinal) + { + "Parent", + "ParentAst", + }; + + /// Base class for tuple-derived synthetic classes. + public const string SyntheticBase = "XppTuple"; + + private const string PositionType = "Microsoft.Dynamics.AX.Metadata.XppCompiler.TextPosition"; + + /// + /// Types that are not part of the Ast hierarchy but are still worth extracting. They + /// are declared by hand in the schema prelude and referenced by the generated classes. + /// + private static readonly Dictionary ExternalTypes = new(StringComparer.Ordinal) + { + ["Microsoft.Dynamics.AX.Framework.Xlnt.XppParser.Comment"] = "Comment", + }; + + public required IReadOnlyList Types { get; init; } + + public required IReadOnlyList Diagnostics { get; init; } + + public static AstModel Build(CompilerPackage package) + { + var astTypes = package.AstAssemblyTypes() + .Where(CompilerPackage.IsAstType) + .Where(t => t.FullName != CompilerPackage.AstRoot) + .OrderBy(t => t.Name, StringComparer.Ordinal) + .ToList(); + + var known = astTypes.Select(TypeName).ToHashSet(StringComparer.Ordinal); + known.Add("Ast"); + + var context = new BuildContext(known); + var result = new List(); + + foreach (var type in astTypes) + { + string? baseName = null; + try + { + var baseType = type.BaseType; + if (baseType is not null && CompilerPackage.IsAstType(baseType)) + baseName = TypeName(baseType); + } + catch + { + // Unresolvable base; reported below. + } + + if (baseName is null) + { + context.Diagnostics.Add($"{type.Name}: could not resolve an Ast base type, rooting at Ast"); + baseName = "Ast"; + } + + var properties = new List(); + PropertyInfo[] declared; + try + { + declared = type.GetProperties( + BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly); + } + catch (Exception e) + { + context.Diagnostics.Add($"{type.Name}: could not read properties ({e.GetType().Name})"); + declared = []; + } + + foreach (var property in declared.OrderBy(p => p.Name, StringComparer.Ordinal)) + { + var classified = context.Classify(type, property); + if (classified.Kind != PropertyKind.Skipped) + properties.Add(classified); + } + + result.Add(new AstType( + TypeName(type), baseName, type.IsAbstract, properties, IsGeneric: IsGeneric(type))); + } + + result.AddRange(context.Synthetics.Values.OrderBy(t => t.Name, StringComparer.Ordinal)); + result = DropInheritedRedeclarations(result); + result = DropUnreferencedSynthetics(result); + result = AddLeavesForConcreteBases(result); + result = DropRedundantPresenceFlags(result); + result = ResolveTableNameConflicts(result); + + return new AstModel { Types = result, Diagnostics = context.Diagnostics }; + } + + /// Mutable state threaded through classification. + private sealed class BuildContext(HashSet known) + { + public List Diagnostics { get; } = []; + + public Dictionary Synthetics { get; } = new(StringComparer.Ordinal); + + public AstProperty Classify(Type owner, PropertyInfo property) + { + var schemaName = ToSnakeCase(property.Name); + + AstProperty Skip(string reason) => + new(property.Name, schemaName, PropertyKind.Skipped, null, reason); + + if (BackReferences.Contains(property.Name)) + return Skip("back-reference"); + + Type propertyType; + try + { + propertyType = property.PropertyType; + } + catch (Exception e) + { + Diagnostics.Add($"{owner.Name}.{property.Name}: unresolvable type ({e.GetType().Name})"); + return Skip("unresolvable type"); + } + + if (FullName(propertyType) == PositionType) + return Skip("source extent, carried by locations"); + + // Dictionaries of AST values: the key is always the value's own name, so only the + // values are represented. + var dictionaryValue = DictionaryValue(propertyType); + if (dictionaryValue is not null) + { + if (IsKnownAst(dictionaryValue)) + return new AstProperty(property.Name, schemaName, PropertyKind.ChildList, TypeName(dictionaryValue), null); + + Diagnostics.Add( + $"{owner.Name}.{property.Name}: dictionary of unsupported value type " + + $"'{FullName(dictionaryValue)}'"); + return Skip("unsupported dictionary value"); + } + + var element = CollectionElement(propertyType); + if (element is not null) + return ClassifyCollection(owner, property, schemaName, element); + + if (IsKnownAst(propertyType)) + return new AstProperty(property.Name, schemaName, PropertyKind.Child, TypeName(propertyType), null); + + if (ExternalTypes.TryGetValue(FullName(propertyType), out var external)) + return new AstProperty(property.Name, schemaName, PropertyKind.Child, external, null); + + if (IsTuple(propertyType)) + { + var synthetic = SynthesizeTuple(owner, property, propertyType); + return synthetic is null + ? Skip("unsupported tuple") + : new AstProperty(property.Name, schemaName, PropertyKind.Child, synthetic, null); + } + + return ClassifyScalar(owner, property, schemaName, propertyType, Skip); + } + + private AstProperty ClassifyCollection( + Type owner, PropertyInfo property, string schemaName, Type element) + { + if (IsKnownAst(element)) + return new AstProperty(property.Name, schemaName, PropertyKind.ChildList, TypeName(element), null); + + if (ExternalTypes.TryGetValue(FullName(element), out var externalElement)) + return new AstProperty(property.Name, schemaName, PropertyKind.ChildList, externalElement, null); + + if (IsTuple(element)) + { + var synthetic = SynthesizeTuple(owner, property, element); + return synthetic is null + ? new AstProperty(property.Name, schemaName, PropertyKind.Skipped, null, "unsupported tuple") + : new AstProperty(property.Name, schemaName, PropertyKind.ChildList, synthetic, null); + } + + if (FullName(element) == PositionType) + { + return new AstProperty( + property.Name, schemaName, PropertyKind.Skipped, null, "source extents"); + } + + if (IsEnum(element)) + return new AstProperty(property.Name, schemaName, PropertyKind.EnumList, TypeName(element), null); + + switch (FullName(element)) + { + case "System.String": + return new AstProperty(property.Name, schemaName, PropertyKind.StringList, null, null); + case "System.Int32": + case "System.Int64": + return new AstProperty(property.Name, schemaName, PropertyKind.IntList, null, null); + } + + Diagnostics.Add( + $"{owner.Name}.{property.Name}: collection of unsupported element type " + + $"'{FullName(element)}'"); + return new AstProperty( + property.Name, schemaName, PropertyKind.Skipped, null, "unsupported collection element"); + } + + private AstProperty ClassifyScalar( + Type owner, PropertyInfo property, string schemaName, Type propertyType, + Func skip) + { + if (IsEnum(propertyType)) + return new AstProperty(property.Name, schemaName, PropertyKind.Enum, TypeName(propertyType), null); + + var underlying = NullableUnderlying(propertyType) ?? propertyType; + + if (IsEnum(underlying)) + return new AstProperty(property.Name, schemaName, PropertyKind.Enum, TypeName(underlying), null); + + switch (FullName(underlying)) + { + case "System.String": + return new AstProperty(property.Name, schemaName, PropertyKind.String, null, null); + case "System.Boolean": + return new AstProperty(property.Name, schemaName, PropertyKind.Boolean, null, null); + case "System.Int32": + case "System.Int64": + return new AstProperty(property.Name, schemaName, PropertyKind.Int, null, null); + } + + Diagnostics.Add($"{owner.Name}.{property.Name}: unsupported type '{FullName(propertyType)}'"); + return skip("unsupported type"); + } + + /// + /// Creates (or reuses) a schema class standing in for a CLR tuple, since the schema has + /// no tuple type. The name is derived from the declaring property so it is stable. + /// + private string? SynthesizeTuple(Type owner, PropertyInfo property, Type tuple) + { + Type[] arguments; + try + { + arguments = tuple.GetGenericArguments(); + } + catch + { + return null; + } + + // The "Entry" suffix keeps the generated table name distinct from the one derived + // from the declaring property itself. + var name = TypeName(owner) + Singularize(property.Name) + "Entry"; + if (Synthetics.ContainsKey(name)) + return name; + + var used = new HashSet(StringComparer.Ordinal); + var fields = new List(); + + for (var i = 0; i < arguments.Length; i++) + { + var argument = arguments[i]; + var position = i + 1; + + var nested = CollectionElement(argument); + if (nested is not null && IsKnownAst(nested)) + { + fields.Add(new AstProperty( + $"Item{position}", Unique(used, ToSnakeCase(TypeName(nested)) + "s"), + PropertyKind.ChildList, TypeName(nested), null)); + continue; + } + + if (IsKnownAst(argument)) + { + fields.Add(new AstProperty( + $"Item{position}", Unique(used, ToSnakeCase(TypeName(argument))), + PropertyKind.Child, TypeName(argument), null)); + continue; + } + + if (ExternalTypes.TryGetValue(FullName(argument), out var external)) + { + fields.Add(new AstProperty( + $"Item{position}", Unique(used, ToSnakeCase(external)), + PropertyKind.Child, external, null)); + continue; + } + + if (FullName(argument) == PositionType) + continue; + + var kind = FullName(argument) switch + { + "System.String" => PropertyKind.String, + "System.Boolean" => PropertyKind.Boolean, + "System.Int32" or "System.Int64" => PropertyKind.Int, + _ => PropertyKind.Skipped, + }; + + if (kind == PropertyKind.Skipped) + { + Diagnostics.Add( + $"{owner.Name}.{property.Name}: tuple element {position} has unsupported " + + $"type '{FullName(argument)}'"); + return null; + } + + fields.Add(new AstProperty( + $"Item{position}", Unique(used, $"item{position}"), kind, null, null)); + } + + Synthetics[name] = new AstType(name, SyntheticBase, false, fields, IsSynthetic: true); + return name; + } + + private static string Unique(HashSet used, string candidate) + { + var name = candidate; + var suffix = 2; + while (!used.Add(name)) + name = $"{candidate}{suffix++}"; + return name; + } + + private bool IsKnownAst(Type type) + { + try + { + return CompilerPackage.IsAstType(type) && known.Contains(TypeName(type)); + } + catch + { + return false; + } + } + } + + /// + /// Gives an explicit dbscheme table name to properties whose derived name would clash with a + /// class table. + /// + /// + /// The generator derives a property's table from tableize("{Class}_{property}") and a + /// class's table from tableize(Class). X++ has classes such as + /// QueryDataSourceHaving alongside a QueryDataSource.Having property, which + /// collide. Since tableize is pluralize composed with underscore, equal + /// underscored forms imply equal table names, so comparing underscored forms is enough to + /// detect the clash without reimplementing English pluralisation. + /// + /// + /// Drops HasX booleans that duplicate the hasX() predicate the QL generator + /// already emits for an optional X property on the same class. + /// + /// + /// Property names inherited from the hand-written prelude by every generated class. + /// + private static readonly string[] PreludeProperties = ["location", "is_unknown"]; + + /// + /// Removes properties that an ancestor already declares. + /// + /// + /// The X++ compiler's classes frequently re-declare an inherited property, either to narrow + /// its type or simply as a `new` member. The schema models inheritance directly, so the + /// ancestor's declaration is the one to keep; re-emitting it on the subclass produces a + /// conflicting, non-overriding QL predicate. + /// + private static List DropInheritedRedeclarations(List types) + { + var byName = types.ToDictionary(t => t.Name, StringComparer.Ordinal); + + HashSet InheritedNames(AstType type) + { + var names = new HashSet(PreludeProperties, StringComparer.Ordinal); + var seen = new HashSet(StringComparer.Ordinal) { type.Name }; + + var baseName = type.BaseName; + while (baseName is not null && byName.TryGetValue(baseName, out var ancestor)) + { + if (!seen.Add(ancestor.Name)) + break; + + foreach (var property in ancestor.Properties) + names.Add(property.SchemaName); + + baseName = ancestor.BaseName; + } + + return names; + } + + return types.Select(type => + { + var inherited = InheritedNames(type); + var properties = type.Properties + .Where(p => !inherited.Contains(p.SchemaName)) + .ToList(); + + return properties.Count == type.Properties.Count + ? type + : type with { Properties = properties }; + }).ToList(); + } + + /// + /// Drops synthetic tuple classes left unreferenced, which happens when the property that + /// introduced one turns out to be an inherited re-declaration. + /// + private static List DropUnreferencedSynthetics(List types) + { + var referenced = types + .SelectMany(t => t.Properties) + .Select(p => p.TypeName) + .Where(n => n is not null) + .ToHashSet(StringComparer.Ordinal)!; + + return types.Where(t => !t.IsSynthetic || referenced.Contains(t.Name)).ToList(); + } + + /// Suffix for the leaf classes standing in for instantiable base classes. + public const string ConcreteBaseLeafSuffix = "Internal"; + + /// + /// Adds a leaf subclass for every instantiable class that also has subclasses. + /// + /// + /// The dbscheme only binds ids in leaf tables: a class with subclasses becomes a union and + /// gets no table of its own. The X++ AST has classes such as FieldExpression that are + /// both instantiable and extended, so instances of exactly that class would have nowhere to + /// bind. A generated leaf gives them one, mirroring the ...Internal classes in the + /// Rust schema. + /// + private static List AddLeavesForConcreteBases(List types) + { + var bases = types + .Select(t => t.BaseName) + .Where(n => n is not null) + .ToHashSet(StringComparer.Ordinal)!; + + var existing = types.Select(t => t.Name).ToHashSet(StringComparer.Ordinal); + + var leaves = types + .Where(t => !t.IsAbstract && bases.Contains(t.Name)) + .Select(t => t.Name + ConcreteBaseLeafSuffix) + .Where(name => !existing.Contains(name)) + .Select(name => new AstType( + name, + name[..^ConcreteBaseLeafSuffix.Length], + IsAbstract: false, + Properties: [])) + .ToList(); + + return types.Concat(leaves).ToList(); + } + + private static List DropRedundantPresenceFlags(List types) + { + return types.Select(type => + { + var optionalNames = type.Properties + .Where(p => p.Kind is PropertyKind.String or PropertyKind.Int or + PropertyKind.Enum or PropertyKind.Child) + .Select(p => p.SchemaName) + .ToHashSet(StringComparer.Ordinal); + + var properties = type.Properties.Where(p => + { + if (p.Kind != PropertyKind.Boolean) + return true; + if (!p.SchemaName.StartsWith("has_", StringComparison.Ordinal)) + return true; + return !optionalNames.Contains(p.SchemaName["has_".Length..]); + }).ToList(); + + return properties.Count == type.Properties.Count + ? type + : type with { Properties = properties }; + }).ToList(); + } + + private static List ResolveTableNameConflicts(List types) + { + var classForms = types + .Select(t => Singularize(ToSnakeCase(t.Name))) + .ToHashSet(StringComparer.Ordinal); + + return types.Select(type => + { + var owner = ToSnakeCase(type.Name); + var properties = type.Properties.Select(property => + { + var derived = $"{owner}_{property.SchemaName}"; + return classForms.Contains(Singularize(derived)) + ? property with { TableName = derived + "_prop" } + : property; + }).ToList(); + + return type with { Properties = properties }; + }).ToList(); + } + + private static string FullName(Type type) + { + try + { + return type.FullName ?? type.Name; + } + catch + { + return type.Name; + } + } + + /// + /// The schema-safe name of a type. CLR generic type names carry an arity suffix + /// (Foo`1) that is not a valid Python identifier. + /// + private static string TypeName(Type type) + { + var name = type.Name; + var tick = name.IndexOf('`'); + return tick < 0 ? name : name[..tick]; + } + + private static bool IsEnum(Type type) + { + try + { + return type.IsEnum; + } + catch + { + return false; + } + } + + private static bool IsGeneric(Type type) + { + try + { + return type.IsGenericTypeDefinition || type.ContainsGenericParameters; + } + catch + { + return false; + } + } + + /// + /// compares against runtime types and so does not + /// work inside a MetadataLoadContext; match on the generic definition instead. + /// + private static Type? NullableUnderlying(Type type) + { + try + { + if (!type.IsGenericType) + return null; + var definition = FullName(type.GetGenericTypeDefinition()); + return definition.StartsWith("System.Nullable`1", StringComparison.Ordinal) + ? type.GetGenericArguments()[0] + : null; + } + catch + { + return null; + } + } + + private static bool IsTuple(Type type) + { + try + { + if (!type.IsGenericType) + return false; + var definition = FullName(type.GetGenericTypeDefinition()); + return definition.StartsWith("System.Tuple`", StringComparison.Ordinal) || + definition.StartsWith("System.ValueTuple`", StringComparison.Ordinal); + } + catch + { + return false; + } + } + + /// Value type if is a dictionary, else null. + private static Type? DictionaryValue(Type type) + { + try + { + if (!type.IsGenericType) + return null; + + var definition = FullName(type.GetGenericTypeDefinition()); + var isDictionary = + definition.StartsWith("System.Collections.Generic.IDictionary`2", StringComparison.Ordinal) || + definition.StartsWith("System.Collections.Generic.Dictionary`2", StringComparison.Ordinal) || + definition.StartsWith("System.Collections.Generic.IReadOnlyDictionary`2", StringComparison.Ordinal) || + definition.StartsWith("Microsoft.Dynamics.AX.Metadata.XppCompiler.LinkedDictionary`2", StringComparison.Ordinal); + + return isDictionary ? type.GetGenericArguments()[1] : null; + } + catch + { + return null; + } + } + + /// Element type if is a supported collection, else null. + private static Type? CollectionElement(Type type) + { + try + { + if (type.IsArray) + return type.GetElementType(); + + if (!type.IsGenericType) + return null; + + var definition = FullName(type.GetGenericTypeDefinition()); + var isCollection = + definition.StartsWith("System.Collections.Generic.List`1", StringComparison.Ordinal) || + definition.StartsWith("System.Collections.Generic.IList`1", StringComparison.Ordinal) || + definition.StartsWith("System.Collections.Generic.ICollection`1", StringComparison.Ordinal) || + definition.StartsWith("System.Collections.Generic.IEnumerable`1", StringComparison.Ordinal) || + definition.StartsWith("System.Collections.Generic.IReadOnlyList`1", StringComparison.Ordinal) || + definition.StartsWith("System.Collections.Generic.ISet`1", StringComparison.Ordinal) || + definition.StartsWith("System.Collections.Generic.HashSet`1", StringComparison.Ordinal) || + definition.StartsWith("System.Collections.ObjectModel.Collection`1", StringComparison.Ordinal) || + definition.StartsWith("System.Collections.ObjectModel.ReadOnlyCollection`1", StringComparison.Ordinal); + + return isCollection ? type.GetGenericArguments()[0] : null; + } + catch + { + return null; + } + } + + /// Crude singularisation, good enough for the property names in this hierarchy. + public static string Singularize(string name) + { + if (name.EndsWith("ies", StringComparison.Ordinal)) + return name[..^3] + "y"; + + // Latin-ish and already-singular endings that must not lose a trailing "s". + foreach (var ending in new[] { "ss", "us", "is" }) + { + if (name.EndsWith(ending, StringComparison.Ordinal)) + return name; + } + + // "Catches", "Boxes", "Bushes", "Buzzes" drop the whole "es". + foreach (var ending in new[] { "ches", "shes", "sses", "xes", "zes" }) + { + if (name.EndsWith(ending, StringComparison.Ordinal)) + return name[..^2]; + } + + if (name.EndsWith("s", StringComparison.Ordinal)) + return name[..^1]; + + return name; + } + + /// Converts a CLR PascalCase identifier to the snake_case the schema uses. + public static string ToSnakeCase(string name) + { + var builder = new StringBuilder(name.Length + 8); + for (var i = 0; i < name.Length; i++) + { + var c = name[i]; + if (char.IsUpper(c)) + { + // Break before a new word, but keep runs of capitals (e.g. "XppType") together. + var previousIsLower = i > 0 && !char.IsUpper(name[i - 1]) && name[i - 1] != '_'; + var nextIsLower = i + 1 < name.Length && char.IsLower(name[i + 1]); + if (i > 0 && (previousIsLower || (char.IsUpper(name[i - 1]) && nextIsLower))) + builder.Append('_'); + builder.Append(char.ToLowerInvariant(c)); + } + else + { + builder.Append(c); + } + } + + return builder.ToString(); + } +} diff --git a/xpp/extractor/Xpp.SchemaGenerator/CompilerPackage.cs b/xpp/extractor/Xpp.SchemaGenerator/CompilerPackage.cs new file mode 100644 index 000000000000..c0d8eadb66b2 --- /dev/null +++ b/xpp/extractor/Xpp.SchemaGenerator/CompilerPackage.cs @@ -0,0 +1,129 @@ +using System.Reflection; + +namespace Xpp.SchemaGenerator; + +/// +/// Reflection-only access to the X++ compiler assemblies shipped in +/// Microsoft.Dynamics.AX.Platform.CompilerPackage. +/// +/// +/// Uses , which reads PE metadata without executing any code +/// from the package. The package is proprietary and is never committed to this repository; the +/// directory is supplied by the caller or via XPP_COMPILER_PACKAGE. +/// +public sealed class CompilerPackage : IDisposable +{ + /// Assembly declaring the X++ AST node classes. + public const string AstAssembly = "Microsoft.Dynamics.AX.Framework.Xlnt.XppCore"; + + /// Namespace shared by the AST node classes. + public const string AstNamespace = "Microsoft.Dynamics.AX.Metadata.XppCompiler"; + + /// Root of the X++ AST class hierarchy. + public const string AstRoot = AstNamespace + ".Ast"; + + private readonly MetadataLoadContext context; + + public CompilerPackage(string packageDirectory) + { + if (!Directory.Exists(packageDirectory)) + throw new DirectoryNotFoundException($"Compiler package directory not found: {packageDirectory}"); + + PackageDirectory = packageDirectory; + + var paths = Directory.GetFiles(packageDirectory, "*.dll", SearchOption.AllDirectories).ToList(); + var present = paths.Select(Path.GetFileNameWithoutExtension) + .ToHashSet(StringComparer.OrdinalIgnoreCase); + + // Package assemblies take precedence; reference assemblies only fill in the BCL. + foreach (var referenceAssembly in ReferenceAssemblyPaths()) + { + if (!present.Contains(Path.GetFileNameWithoutExtension(referenceAssembly))) + paths.Add(referenceAssembly); + } + + context = new MetadataLoadContext(new PathAssemblyResolver(paths), "mscorlib"); + } + + public string PackageDirectory { get; } + + /// + /// Locates the net472 reference assemblies restored alongside this tool. They are required + /// because the XLNT assemblies target .NET Framework. + /// + private static IEnumerable ReferenceAssemblyPaths() + { + var roots = new List(); + + var packageRoot = Environment.GetEnvironmentVariable("NUGET_PACKAGES"); + if (string.IsNullOrEmpty(packageRoot)) + { + packageRoot = Path.Combine( + Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), + ".nuget", "packages"); + } + + var referencePackage = Path.Combine(packageRoot, "microsoft.netframework.referenceassemblies.net472"); + if (Directory.Exists(referencePackage)) + { + // Any restored version will do; the BCL surface we need is stable across them. + foreach (var version in Directory.GetDirectories(referencePackage).OrderByDescending(d => d)) + { + var dir = Path.Combine(version, "build", ".NETFramework", "v4.7.2"); + if (Directory.Exists(dir)) + { + roots.Add(dir); + break; + } + } + } + + return roots.SelectMany(r => Directory.GetFiles(r, "*.dll")); + } + + /// Every type in the AST assembly, tolerating unresolvable references. + public IReadOnlyList AstAssemblyTypes() + { + var assembly = context.LoadFromAssemblyPath( + Path.Combine(PackageDirectory, AstAssembly + ".dll")); + try + { + return assembly.GetTypes(); + } + catch (ReflectionTypeLoadException e) + { + return e.Types.Where(t => t is not null).ToArray()!; + } + } + + /// The base-class chain of , outermost last. + public static IReadOnlyList BaseChain(Type type) + { + var chain = new List(); + var current = type; + while (true) + { + try + { + current = current.BaseType; + } + catch + { + break; + } + + if (current is null) + break; + + chain.Add(current.FullName ?? current.Name); + } + + return chain; + } + + /// True if is Ast or derives from it. + public static bool IsAstType(Type type) => + type.FullName == AstRoot || BaseChain(type).Contains(AstRoot); + + public void Dispose() => context.Dispose(); +} diff --git a/xpp/extractor/Xpp.SchemaGenerator/Inflection.cs b/xpp/extractor/Xpp.SchemaGenerator/Inflection.cs new file mode 100644 index 000000000000..f99794b33c1e --- /dev/null +++ b/xpp/extractor/Xpp.SchemaGenerator/Inflection.cs @@ -0,0 +1,85 @@ +using System.Text; +using System.Text.RegularExpressions; + +namespace Xpp.SchemaGenerator; + +/// +/// The subset of the Python inflection package's behaviour that misc/codegen +/// relies on when deriving dbscheme table names. +/// +/// +/// Table names are produced by inflection.tableize, so the TRAP writer has to agree with +/// it exactly. Rather than trust this reimplementation, the generator validates every name it +/// produces against the committed dbscheme and fails if one is missing. +/// +public static partial class Inflection +{ + private static readonly (Regex Pattern, string Replacement)[] PluralRules = + [ + (MakeRegex("(quiz)$"), "$1zes"), + (MakeRegex("^(oxen)$"), "$1"), + (MakeRegex("^(ox)$"), "$1en"), + (MakeRegex("(m|l)ouse$"), "$1ice"), + (MakeRegex("(matr|vert|ind)(?:ix|ex)$"), "$1ices"), + (MakeRegex("(x|ch|ss|sh)$"), "$1es"), + (MakeRegex("([^aeiouy]|qu)y$"), "$1ies"), + (MakeRegex("(hive)$"), "$1s"), + (MakeRegex("(?:([^f])fe|([lr])f)$"), "$1$2ves"), + (MakeRegex("sis$"), "ses"), + (MakeRegex("([ti])um$"), "$1a"), + (MakeRegex("(buffal|tomat)o$"), "$1oes"), + (MakeRegex("(bu)s$"), "$1ses"), + (MakeRegex("(alias|status)$"), "$1es"), + (MakeRegex("(octop|vir)us$"), "$1i"), + (MakeRegex("(ax|test)is$"), "$1es"), + (MakeRegex("s$"), "s"), + (MakeRegex("$"), "s"), + ]; + + private static Regex MakeRegex(string pattern) => + new(pattern, RegexOptions.IgnoreCase | RegexOptions.Compiled); + + /// Pluralises a lower_snake_case word, matching inflection.pluralize. + public static string Pluralize(string word) + { + if (word.Length == 0) + return word; + + // `inflection` scans its rule list in order and applies the first match, so the specific + // rules must be tried before the catch-all that simply appends "s". + foreach (var (pattern, replacement) in PluralRules) + { + if (pattern.IsMatch(word)) + return pattern.Replace(word, replacement, 1); + } + + return word; + } + + /// Converts a CLR PascalCase identifier to snake_case, matching underscore. + public static string Underscore(string name) + { + var builder = new StringBuilder(name.Length + 8); + for (var i = 0; i < name.Length; i++) + { + var c = name[i]; + if (char.IsUpper(c)) + { + var previousIsLower = i > 0 && !char.IsUpper(name[i - 1]) && name[i - 1] != '_'; + var nextIsLower = i + 1 < name.Length && char.IsLower(name[i + 1]); + if (i > 0 && (previousIsLower || (char.IsUpper(name[i - 1]) && nextIsLower))) + builder.Append('_'); + builder.Append(char.ToLowerInvariant(c)); + } + else + { + builder.Append(c); + } + } + + return builder.ToString(); + } + + /// Equivalent of inflection.tableize: underscore, then pluralise. + public static string Tableize(string name) => Pluralize(Underscore(name)); +} diff --git a/xpp/extractor/Xpp.SchemaGenerator/Program.cs b/xpp/extractor/Xpp.SchemaGenerator/Program.cs new file mode 100644 index 000000000000..3db130d5d511 --- /dev/null +++ b/xpp/extractor/Xpp.SchemaGenerator/Program.cs @@ -0,0 +1,108 @@ +using Xpp.SchemaGenerator; + +// Regenerates xpp/schema/ast.py from the X++ compiler package's AST hierarchy. +// +// Xpp.SchemaGenerator [args] [--package ] [--output ] +// +// Commands: +// schema write the generated schema module +// report summarise the reflected model and any unmapped properties +// type dump the members of a single type, for investigation + +var positional = new List(); +string? packageDirectory = null; +string? output = null; + +for (var i = 0; i < args.Length; i++) +{ + switch (args[i]) + { + case "--package" when i + 1 < args.Length: + packageDirectory = args[++i]; + break; + case "--output" when i + 1 < args.Length: + output = args[++i]; + break; + default: + positional.Add(args[i]); + break; + } +} + +var command = positional.Count > 0 ? positional[0] : "report"; + +packageDirectory ??= Environment.GetEnvironmentVariable("XPP_COMPILER_PACKAGE"); + +if (string.IsNullOrEmpty(packageDirectory)) +{ + Console.Error.WriteLine( + "No compiler package directory. Pass --package or set XPP_COMPILER_PACKAGE."); + return 2; +} + +using var package = new CompilerPackage(packageDirectory); +var model = AstModel.Build(package); + +switch (command) +{ + case "schema": + var schema = SchemaWriter.Render(model); + if (output is null) + { + Console.Write(schema); + } + else + { + Directory.CreateDirectory(Path.GetDirectoryName(Path.GetFullPath(output))!); + File.WriteAllText(output, schema); + Console.Error.WriteLine( + $"wrote {model.Types.Count} types to {output} ({model.Diagnostics.Count} diagnostics)"); + } + + return 0; + + case "report": + Console.Write(SchemaWriter.RenderReport(model)); + return 0; + + case "trap": + var dbscheme = positional.Count > 1 + ? positional[1] + : Path.Combine(Directory.GetCurrentDirectory(), "ql", "lib", "xpp.dbscheme"); + + if (!File.Exists(dbscheme)) + { + Console.Error.WriteLine($"dbscheme not found: {dbscheme}"); + Console.Error.WriteLine("Generate it first, then rerun; the TRAP writer is checked against it."); + return 2; + } + + var tables = TrapEmitterWriter.ReadDbschemeTables(dbscheme); + string emitter; + try + { + emitter = TrapEmitterWriter.Render(model, tables); + } + catch (InvalidOperationException e) + { + Console.Error.WriteLine(e.Message); + return 1; + } + + if (output is null) + { + Console.Write(emitter); + } + else + { + Directory.CreateDirectory(Path.GetDirectoryName(Path.GetFullPath(output))!); + File.WriteAllText(output, emitter); + Console.Error.WriteLine($"wrote TRAP emitter to {output}, validated against {tables.Count} relations"); + } + + return 0; + + default: + Console.Error.WriteLine($"Unknown command '{command}'. Expected 'schema', 'trap' or 'report'."); + return 2; +} diff --git a/xpp/extractor/Xpp.SchemaGenerator/SchemaWriter.cs b/xpp/extractor/Xpp.SchemaGenerator/SchemaWriter.cs new file mode 100644 index 000000000000..e2c1f9f5e603 --- /dev/null +++ b/xpp/extractor/Xpp.SchemaGenerator/SchemaWriter.cs @@ -0,0 +1,163 @@ +namespace Xpp.SchemaGenerator; + +/// +/// Renders an as the Python schema module consumed by +/// misc/codegen. +/// +public static class SchemaWriter +{ + /// Reserved words that cannot be used bare as schema property names. + private static readonly HashSet PythonKeywords = new(StringComparer.Ordinal) + { + "and", "as", "assert", "async", "await", "break", "class", "continue", "def", "del", + "elif", "else", "except", "finally", "for", "from", "global", "if", "import", "in", + "is", "lambda", "none", "nonlocal", "not", "or", "pass", "raise", "return", "try", + "while", "with", "yield", + }; + + /// + /// Names defined by the schema prelude or by schemadefs that a property must not + /// shadow. + /// + private static readonly HashSet ReservedNames = new(StringComparer.Ordinal) + { + "int", "string", "boolean", "predicate", "optional", "list", "set", "child", "synth", + }; + + /// + /// Names supplied by the hand-written prelude. Generated classes may derive from these + /// without the generator emitting them. + /// + private static readonly HashSet PreludeTypes = new(StringComparer.Ordinal) + { + "Element", "File", "Location", "Locatable", "ErrorElement", "UnspecifiedElement", + "Comment", "Ast", "XppTuple", + }; + + public static string Render(AstModel model) + { + var writer = new StringWriter(); + + writer.WriteLine("# Generated by xpp/extractor/Xpp.SchemaGenerator, do not edit by hand."); + writer.WriteLine("#"); + writer.WriteLine("# Source: Microsoft.Dynamics.AX.Framework.Xlnt.XppCore.dll"); + writer.WriteLine("# from Microsoft.Dynamics.AX.Platform.CompilerPackage."); + writer.WriteLine("#"); + writer.WriteLine("# Regenerate with `xpp/tools/generate-schema.sh`."); + writer.WriteLine(); + writer.WriteLine("from .prelude import *"); + writer.WriteLine(); + + foreach (var type in InDefinitionOrder(model.Types)) + { + writer.WriteLine(); + writer.WriteLine($"class {type.Name}({type.BaseName}):"); + + if (type.Properties.Count == 0) + { + writer.WriteLine(" pass"); + continue; + } + + foreach (var property in type.Properties) + writer.WriteLine($" {RenderProperty(property)}"); + } + + return writer.ToString(); + } + + /// + /// Orders types so that every class is emitted after its base, which Python requires. Ties + /// are broken alphabetically so the output is stable across runs. + /// + private static IEnumerable InDefinitionOrder(IReadOnlyList types) + { + var pending = types.OrderBy(t => t.Name, StringComparer.Ordinal).ToList(); + var emitted = new HashSet(PreludeTypes, StringComparer.Ordinal); + var ordered = new List(pending.Count); + + while (pending.Count > 0) + { + var ready = pending.Where(t => t.BaseName is null || emitted.Contains(t.BaseName)).ToList(); + if (ready.Count == 0) + { + // A cycle, or a base that is neither generated nor in the prelude. Emitting the + // remainder keeps the failure visible in the generated file rather than here. + ordered.AddRange(pending); + break; + } + + foreach (var type in ready) + { + ordered.Add(type); + emitted.Add(type.Name); + pending.Remove(type); + } + } + + return ordered; + } + + private static string RenderProperty(AstProperty property) + { + var name = SafeName(property.SchemaName); + + var rendered = property.Kind switch + { + PropertyKind.Child => $"{name}: optional[\"{property.TypeName}\"] | child", + PropertyKind.ChildList => $"{name}: list[\"{property.TypeName}\"] | child", + PropertyKind.String => $"{name}: optional[string]", + PropertyKind.StringList => $"{name}: list[string]", + PropertyKind.Boolean => $"{name}: predicate", + PropertyKind.Int => $"{name}: optional[int]", + PropertyKind.IntList => $"{name}: list[int]", + // Enums are recorded by member name so the schema does not depend on numeric + // values that can shift between platform releases. + PropertyKind.Enum => $"{name}: optional[string]", + PropertyKind.EnumList => $"{name}: list[string]", + _ => throw new InvalidOperationException( + $"cannot render skipped property {property.ClrName}"), + }; + + return property.TableName is null + ? rendered + : $"{rendered} | ql.db_table_name(\"{property.TableName}\")"; + } + + private static string SafeName(string name) => + PythonKeywords.Contains(name) || ReservedNames.Contains(name) ? name + "_" : name; + + /// A human-readable report of the model, used to review generator coverage. + public static string RenderReport(AstModel model) + { + var writer = new StringWriter(); + + writer.WriteLine($"types: {model.Types.Count}"); + writer.WriteLine($"abstract: {model.Types.Count(t => t.IsAbstract)}"); + writer.WriteLine($"properties: {model.Types.Sum(t => t.Properties.Count)}"); + writer.WriteLine(); + + foreach (var group in model.Types + .SelectMany(t => t.Properties) + .GroupBy(p => p.Kind) + .OrderByDescending(g => g.Count())) + { + writer.WriteLine($" {group.Count(),5} {group.Key}"); + } + + if (model.Diagnostics.Count > 0) + { + writer.WriteLine(); + writer.WriteLine($"diagnostics: {model.Diagnostics.Count}"); + foreach (var group in model.Diagnostics.GroupBy(d => d.Split(": ").Last()) + .OrderByDescending(g => g.Count())) + { + writer.WriteLine($" {group.Count(),5} {group.Key}"); + foreach (var item in group.Take(5)) + writer.WriteLine($" {item}"); + } + } + + return writer.ToString(); + } +} diff --git a/xpp/extractor/Xpp.SchemaGenerator/TrapEmitterWriter.cs b/xpp/extractor/Xpp.SchemaGenerator/TrapEmitterWriter.cs new file mode 100644 index 000000000000..d1aadeab944b --- /dev/null +++ b/xpp/extractor/Xpp.SchemaGenerator/TrapEmitterWriter.cs @@ -0,0 +1,329 @@ +using System.Text; +using System.Text.RegularExpressions; + +namespace Xpp.SchemaGenerator; + +/// +/// Emits the C# that writes TRAP tuples for a parsed X++ AST. +/// +/// +/// The relation names are derived with so they match what +/// misc/codegen put in the dbscheme. Every derived name is checked against the committed +/// dbscheme before anything is written, so a divergence fails the build rather than producing a +/// database that silently drops tuples. +/// +public static partial class TrapEmitterWriter +{ + private const string AstNamespace = CompilerPackage.AstNamespace; + + [GeneratedRegex(@"^([a-z_][a-z0-9_]*)\(", RegexOptions.Multiline)] + private static partial Regex TableDeclaration(); + + /// Table names declared by the generated dbscheme. + public static HashSet ReadDbschemeTables(string dbschemePath) + { + var text = File.ReadAllText(dbschemePath); + return TableDeclaration().Matches(text) + .Select(m => m.Groups[1].Value) + .ToHashSet(StringComparer.Ordinal); + } + + private static string ClassTable(AstType type) => Inflection.Tableize(type.Name); + + private static string PropertyTable(AstType type, AstProperty property) + { + if (property.TableName is not null) + return property.TableName; + + var qualified = $"{type.Name}_{property.SchemaName}"; + + // Predicate tables hold no value column, and the generator names them with `underscore` + // rather than `tableize`, so they are not pluralised. + return property.Kind == PropertyKind.Boolean + ? Inflection.Underscore(qualified) + : Inflection.Tableize(qualified); + } + + public static string Render(AstModel model, HashSet dbschemeTables) + { + var byName = model.Types.ToDictionary(t => t.Name, StringComparer.Ordinal); + var missing = new List(); + + void Require(string table) + { + if (!dbschemeTables.Contains(table)) + missing.Add(table); + } + + // Only leaf classes get a binding table; everything else is a union in the dbscheme. + var bases = model.Types.Select(t => t.BaseName).Where(n => n is not null) + .ToHashSet(StringComparer.Ordinal)!; + var leaves = model.Types.Where(t => !bases.Contains(t.Name)).ToList(); + + var writer = new StringWriter(); + Header(writer); + + writer.WriteLine("internal static class AstTrapEmitter"); + writer.WriteLine("{"); + writer.WriteLine(); + writer.WriteLine(" /// "); + writer.WriteLine(" /// Labels a child and records it, so the caller walks the same instances that were"); + writer.WriteLine(" /// labelled here. Reading a property twice is not safe: some are structs, which box"); + writer.WriteLine(" /// to a new object on each read and would otherwise get two different labels."); + writer.WriteLine(" /// "); + writer.WriteLine(" private static Label Child(ITrapFile trap, ICollection children, object node)"); + writer.WriteLine(" {"); + writer.WriteLine(" children.Add(node);"); + writer.WriteLine(" return trap.Label(node);"); + writer.WriteLine(" }"); + + // Per-class emission of that class's own properties. + foreach (var type in model.Types.OrderBy(t => t.Name, StringComparer.Ordinal)) + { + if (type.Properties.Count == 0 || type.IsSynthetic) + continue; + + writer.WriteLine(); + writer.WriteLine($" private static void EmitOwn{type.Name}(ITrapFile trap, Label id, object node, ICollection children)"); + writer.WriteLine(" {"); + if (type.IsGeneric) + { + // An open generic class cannot be named, so bind its members late. + writer.WriteLine(" dynamic n = node;"); + } + else + { + writer.WriteLine($" var n = ({AstNamespace}.{type.Name})node;"); + } + + foreach (var property in type.Properties) + { + var table = PropertyTable(type, property); + Require(table); + EmitProperty(writer, " ", table, property, byName); + } + + writer.WriteLine(" }"); + } + + // Synthetic tuple helpers. + foreach (var type in model.Types.Where(t => t.IsSynthetic) + .OrderBy(t => t.Name, StringComparer.Ordinal)) + { + var classTable = ClassTable(type); + Require(classTable); + + writer.WriteLine(); + writer.WriteLine($" private static Label Emit{type.Name}(ITrapFile trap, ICollection children, ITuple tuple)"); + writer.WriteLine(" {"); + writer.WriteLine(" var id = trap.FreshLabel();"); + writer.WriteLine($" trap.Tuple(\"{classTable}\", id);"); + foreach (var property in type.Properties) + { + var table = PropertyTable(type, property); + Require(table); + EmitTupleField(writer, " ", table, property, byName); + } + + writer.WriteLine(" return id;"); + writer.WriteLine(" }"); + } + + EmitDispatch(writer, model, byName, leaves, Require); + + writer.WriteLine("}"); + + if (missing.Count > 0) + { + throw new InvalidOperationException( + "the following relations are not declared in the dbscheme, so the TRAP writer " + + "and the dbscheme have diverged:" + Environment.NewLine + + string.Join(Environment.NewLine, missing.Distinct().OrderBy(x => x).Select(m => " " + m))); + } + + return writer.ToString(); + } + + private static void EmitDispatch( + StringWriter writer, AstModel model, Dictionary byName, + List leaves, Action require) + { + writer.WriteLine(); + writer.WriteLine(" /// "); + writer.WriteLine(" /// Writes every tuple describing , returning false when the"); + writer.WriteLine(" /// node's type is not part of the generated schema."); + writer.WriteLine(" /// "); + writer.WriteLine(" public static bool Emit(ITrapFile trap, Label id, object node, ICollection children)"); + writer.WriteLine(" {"); + writer.WriteLine(" // Dispatch on the exact runtime type: C# type patterns also match subclasses,"); + writer.WriteLine(" // which would bind a node to an ancestor's table."); + writer.WriteLine(" switch (node.GetType().FullName)"); + writer.WriteLine(" {"); + + foreach (var leaf in leaves.Where(l => !l.IsSynthetic && !l.IsGeneric) + .OrderBy(l => l.Name, StringComparer.Ordinal)) + { + // A generated `...Internal` leaf stands in for its instantiable base class. + var runtimeName = leaf.Name.EndsWith(AstModel.ConcreteBaseLeafSuffix, StringComparison.Ordinal) && + byName.ContainsKey(leaf.Name[..^AstModel.ConcreteBaseLeafSuffix.Length]) + ? leaf.Name[..^AstModel.ConcreteBaseLeafSuffix.Length] + : leaf.Name; + + var classTable = ClassTable(leaf); + require(classTable); + + writer.WriteLine($" case \"{AstNamespace}.{runtimeName}\":"); + writer.WriteLine($" trap.Tuple(\"{classTable}\", id);"); + + foreach (var ancestor in Ancestry(leaf, byName)) + { + if (ancestor.Properties.Count > 0) + writer.WriteLine($" EmitOwn{ancestor.Name}(trap, id, node, children);"); + } + + writer.WriteLine(" return true;"); + } + + writer.WriteLine(" default:"); + writer.WriteLine(" return false;"); + writer.WriteLine(" }"); + writer.WriteLine(" }"); + } + + /// The class itself and its ancestors, outermost first. + private static List Ancestry(AstType type, Dictionary byName) + { + var chain = new List(); + var current = type; + var seen = new HashSet(StringComparer.Ordinal); + while (current is not null && seen.Add(current.Name)) + { + chain.Add(current); + current = current.BaseName is not null && byName.TryGetValue(current.BaseName, out var b) + ? b + : null; + } + + chain.Reverse(); + return chain; + } + + private static void EmitProperty( + StringWriter writer, string indent, string table, AstProperty property, + Dictionary byName) + { + var access = $"n.{property.ClrName}"; + EmitValue(writer, indent, table, property, access, byName); + } + + private static void EmitTupleField( + StringWriter writer, string indent, string table, AstProperty property, + Dictionary byName) + { + // Synthetic properties are named Item1..ItemN after their tuple position. + var position = int.Parse(property.ClrName["Item".Length..]) - 1; + EmitValue(writer, indent, table, property, $"tuple[{position}]", byName); + } + + private static void EmitValue( + StringWriter writer, string indent, string table, AstProperty property, string access, + Dictionary byName) + { + switch (property.Kind) + { + case PropertyKind.Child when IsSynthetic(property, byName): + writer.WriteLine($"{indent}if ({access} is ITuple t_{property.SchemaName})"); + writer.WriteLine($"{indent} trap.Tuple(\"{table}\", id, Emit{property.TypeName}(trap, children, t_{property.SchemaName}));"); + break; + + case PropertyKind.Child: + writer.WriteLine($"{indent}if ({access} is {{ }} c_{property.SchemaName})"); + writer.WriteLine($"{indent} trap.Tuple(\"{table}\", id, Child(trap, children, c_{property.SchemaName}));"); + break; + + case PropertyKind.ChildList when IsSynthetic(property, byName): + Loop(writer, indent, access, property, + $"trap.Tuple(\"{table}\", id, i, Emit{property.TypeName}(trap, children, (ITuple)item));", + "ITuple"); + break; + + case PropertyKind.ChildList: + Loop(writer, indent, access, property, + $"trap.Tuple(\"{table}\", id, i, Child(trap, children, item));", + "object"); + break; + + case PropertyKind.String: + writer.WriteLine($"{indent}if ({access} is string s_{property.SchemaName})"); + writer.WriteLine($"{indent} trap.Tuple(\"{table}\", id, s_{property.SchemaName});"); + break; + + case PropertyKind.Boolean: + // Covers `bool`, `bool?` and the boxed value of a tuple slot. + writer.WriteLine($"{indent}if ({access} is true)"); + writer.WriteLine($"{indent} trap.Tuple(\"{table}\", id);"); + break; + + case PropertyKind.Int: + writer.WriteLine($"{indent}if ({access} is {{ }} v_{property.SchemaName})"); + writer.WriteLine($"{indent} trap.Tuple(\"{table}\", id, System.Convert.ToInt64(v_{property.SchemaName}));"); + break; + + case PropertyKind.Enum: + writer.WriteLine($"{indent}if ({access} is {{ }} e_{property.SchemaName})"); + writer.WriteLine($"{indent} trap.Tuple(\"{table}\", id, e_{property.SchemaName}.ToString());"); + break; + + case PropertyKind.StringList: + Loop(writer, indent, access, property, + $"trap.Tuple(\"{table}\", id, i, (string)item);", "string"); + break; + + case PropertyKind.IntList: + Loop(writer, indent, access, property, + $"trap.Tuple(\"{table}\", id, i, System.Convert.ToInt64(item));", "object"); + break; + + case PropertyKind.EnumList: + Loop(writer, indent, access, property, + $"trap.Tuple(\"{table}\", id, i, item.ToString());", "object"); + break; + } + } + + private static void Loop( + StringWriter writer, string indent, string access, AstProperty property, string body, + string _) + { + var seq = $"seq_{property.SchemaName}"; + // AstSequence flattens dictionary entries to their values; iterating the raw collection + // would yield KeyValuePair and label the wrong thing. + writer.WriteLine($"{indent}{{"); + writer.WriteLine($"{indent} var i = 0;"); + writer.WriteLine($"{indent} foreach (var item in AstSequence.Elements({access}))"); + writer.WriteLine($"{indent} {{"); + writer.WriteLine($"{indent} {body}"); + writer.WriteLine($"{indent} i++;"); + writer.WriteLine($"{indent} }}"); + writer.WriteLine($"{indent}}}"); + } + + private static bool IsSynthetic(AstProperty property, Dictionary byName) => + property.TypeName is not null && + byName.TryGetValue(property.TypeName, out var t) && + t.IsSynthetic; + + private static void Header(StringWriter writer) + { + writer.WriteLine("// Generated by xpp/extractor/Xpp.SchemaGenerator, do not edit by hand."); + writer.WriteLine("//"); + writer.WriteLine("// Relation names are validated against xpp/ql/lib/xpp.dbscheme at generation time."); + writer.WriteLine("// Regenerate with `xpp/tools/generate-schema.sh`."); + writer.WriteLine(); + writer.WriteLine("using System.Runtime.CompilerServices;"); + writer.WriteLine("using Xpp.Extraction;"); + writer.WriteLine(); + writer.WriteLine("namespace Xpp.Extraction.Generated;"); + writer.WriteLine(); + } +} diff --git a/xpp/extractor/Xpp.SchemaGenerator/Xpp.SchemaGenerator.csproj b/xpp/extractor/Xpp.SchemaGenerator/Xpp.SchemaGenerator.csproj new file mode 100644 index 000000000000..ccb8e4bebc5b --- /dev/null +++ b/xpp/extractor/Xpp.SchemaGenerator/Xpp.SchemaGenerator.csproj @@ -0,0 +1,19 @@ + + + + Exe + net8.0 + enable + enable + Xpp.SchemaGenerator + Xpp.SchemaGenerator + + + + + + + + + diff --git a/xpp/extractor/xpp.sln b/xpp/extractor/xpp.sln new file mode 100644 index 000000000000..3e2c7f060c73 --- /dev/null +++ b/xpp/extractor/xpp.sln @@ -0,0 +1,62 @@ + +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio Version 17 +VisualStudioVersion = 17.0.31903.59 +MinimumVisualStudioVersion = 10.0.40219.1 +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Xpp.Extraction", "Xpp.Extraction\Xpp.Extraction.csproj", "{C335E196-8D9E-4329-BC4B-154A875BAB77}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Xpp.Extractor", "Xpp.Extractor\Xpp.Extractor.csproj", "{5AE9C274-4F4D-4369-9923-112DF3CDDA37}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Xpp.SchemaGenerator", "Xpp.SchemaGenerator\Xpp.SchemaGenerator.csproj", "{74F454CE-264F-442A-91EC-0000C00A7F6D}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Any CPU = Debug|Any CPU + Debug|x64 = Debug|x64 + Debug|x86 = Debug|x86 + Release|Any CPU = Release|Any CPU + Release|x64 = Release|x64 + Release|x86 = Release|x86 + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {C335E196-8D9E-4329-BC4B-154A875BAB77}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {C335E196-8D9E-4329-BC4B-154A875BAB77}.Debug|Any CPU.Build.0 = Debug|Any CPU + {C335E196-8D9E-4329-BC4B-154A875BAB77}.Debug|x64.ActiveCfg = Debug|Any CPU + {C335E196-8D9E-4329-BC4B-154A875BAB77}.Debug|x64.Build.0 = Debug|Any CPU + {C335E196-8D9E-4329-BC4B-154A875BAB77}.Debug|x86.ActiveCfg = Debug|Any CPU + {C335E196-8D9E-4329-BC4B-154A875BAB77}.Debug|x86.Build.0 = Debug|Any CPU + {C335E196-8D9E-4329-BC4B-154A875BAB77}.Release|Any CPU.ActiveCfg = Release|Any CPU + {C335E196-8D9E-4329-BC4B-154A875BAB77}.Release|Any CPU.Build.0 = Release|Any CPU + {C335E196-8D9E-4329-BC4B-154A875BAB77}.Release|x64.ActiveCfg = Release|Any CPU + {C335E196-8D9E-4329-BC4B-154A875BAB77}.Release|x64.Build.0 = Release|Any CPU + {C335E196-8D9E-4329-BC4B-154A875BAB77}.Release|x86.ActiveCfg = Release|Any CPU + {C335E196-8D9E-4329-BC4B-154A875BAB77}.Release|x86.Build.0 = Release|Any CPU + {5AE9C274-4F4D-4369-9923-112DF3CDDA37}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {5AE9C274-4F4D-4369-9923-112DF3CDDA37}.Debug|Any CPU.Build.0 = Debug|Any CPU + {5AE9C274-4F4D-4369-9923-112DF3CDDA37}.Debug|x64.ActiveCfg = Debug|Any CPU + {5AE9C274-4F4D-4369-9923-112DF3CDDA37}.Debug|x64.Build.0 = Debug|Any CPU + {5AE9C274-4F4D-4369-9923-112DF3CDDA37}.Debug|x86.ActiveCfg = Debug|Any CPU + {5AE9C274-4F4D-4369-9923-112DF3CDDA37}.Debug|x86.Build.0 = Debug|Any CPU + {5AE9C274-4F4D-4369-9923-112DF3CDDA37}.Release|Any CPU.ActiveCfg = Release|Any CPU + {5AE9C274-4F4D-4369-9923-112DF3CDDA37}.Release|Any CPU.Build.0 = Release|Any CPU + {5AE9C274-4F4D-4369-9923-112DF3CDDA37}.Release|x64.ActiveCfg = Release|Any CPU + {5AE9C274-4F4D-4369-9923-112DF3CDDA37}.Release|x64.Build.0 = Release|Any CPU + {5AE9C274-4F4D-4369-9923-112DF3CDDA37}.Release|x86.ActiveCfg = Release|Any CPU + {5AE9C274-4F4D-4369-9923-112DF3CDDA37}.Release|x86.Build.0 = Release|Any CPU + {74F454CE-264F-442A-91EC-0000C00A7F6D}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {74F454CE-264F-442A-91EC-0000C00A7F6D}.Debug|Any CPU.Build.0 = Debug|Any CPU + {74F454CE-264F-442A-91EC-0000C00A7F6D}.Debug|x64.ActiveCfg = Debug|Any CPU + {74F454CE-264F-442A-91EC-0000C00A7F6D}.Debug|x64.Build.0 = Debug|Any CPU + {74F454CE-264F-442A-91EC-0000C00A7F6D}.Debug|x86.ActiveCfg = Debug|Any CPU + {74F454CE-264F-442A-91EC-0000C00A7F6D}.Debug|x86.Build.0 = Debug|Any CPU + {74F454CE-264F-442A-91EC-0000C00A7F6D}.Release|Any CPU.ActiveCfg = Release|Any CPU + {74F454CE-264F-442A-91EC-0000C00A7F6D}.Release|Any CPU.Build.0 = Release|Any CPU + {74F454CE-264F-442A-91EC-0000C00A7F6D}.Release|x64.ActiveCfg = Release|Any CPU + {74F454CE-264F-442A-91EC-0000C00A7F6D}.Release|x64.Build.0 = Release|Any CPU + {74F454CE-264F-442A-91EC-0000C00A7F6D}.Release|x86.ActiveCfg = Release|Any CPU + {74F454CE-264F-442A-91EC-0000C00A7F6D}.Release|x86.Build.0 = Release|Any CPU + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection +EndGlobal diff --git a/xpp/prefix.dbscheme b/xpp/prefix.dbscheme new file mode 100644 index 000000000000..b422464bb902 --- /dev/null +++ b/xpp/prefix.dbscheme @@ -0,0 +1,6 @@ +/** + * The source location of the snapshot. + */ +sourceLocationPrefix( + string prefix: string ref +); diff --git a/xpp/ql/.generated.list b/xpp/ql/.generated.list new file mode 100644 index 000000000000..c2e2b4b851b8 --- /dev/null +++ b/xpp/ql/.generated.list @@ -0,0 +1,1217 @@ +build/extractor-tests/AddExpression/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/AllFieldsSelection/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/AndExpression/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/AnyType/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/ArraySpecification/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/AsClrExpression/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/AsExpression/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/AssignDecrementStatement/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/AssignDivideStatement/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/AssignEqualStatement/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/AssignIncrementStatement/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/AssignMultipleFieldStatement/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/AssignMultiplyStatement/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/AssignPostDecrementStatement/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/AssignPostIncrementStatement/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/AssignPreDecrementStatement/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/AssignPreIncrementStatement/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/AssignmentEventHandlerClr/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/AssignmentEventHandlerInstance/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/AssignmentEventHandlerStaticInternal/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/Attribute/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/AttributeExpression/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/AttributeList/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/AttributeNamedParameterEntry/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/AvgAggregateSelection/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/BooleanAttributeLiteral/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/BooleanLiteralExpression/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/BooleanType/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/BreakStatement/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/BreakpointStatement/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/CaseDefault/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/CaseValues/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/CatchAllValues/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/CatchExpression/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/CatchUpdateConflict/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/ChangeCompanyStatement/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/Class/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/ClassAccessModifier/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/ClrEnumerationLiteralExpression/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/ClrType/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/Comment/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/CompilationUnitRegionEntry/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/CompoundStatement/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/ConditionalExpression/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/ContainerAttributeLiteral/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/ContainerLiteralExpression/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/ContainerType/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/ContinueStatement/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/CountAggregateSelection/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/CrossCompanyAll/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/CrossCompanyContainer/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/DateAttributeLiteral/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/DateLiteralExpression/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/DateTimeAttributeLiteral/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/DateTimeLiteralExpression/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/DateTimeType/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/DateType/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/DblAttributeLiteral/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/DblType/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/Delegate/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/DeleteStatement/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/DivideExpression/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/DoWhileStatement/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/EmptyExpression/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/EmptyStatement/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/EnumAttributeLiteral/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/EnumerationLiteralExpression/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/EnumerationType/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/EqualExpression/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/EvaluationActualParameterEntry/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/ExplicitSelection/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/ExpressionCompilationUnit/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/ExpressionQualifier/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/ExpressionStatement/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/FieldAssignment/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/FieldDeclarationInternal/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/FieldExpressionInternal/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/FieldSelection/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/File/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/FindStatement/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/FlushStatement/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/ForDeclarationAssign/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/ForFieldAssign/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/ForFieldDecrementAssign/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/ForFieldIncrementAssign/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/ForFieldPostDecrement/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/ForFieldPostIncrement/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/ForFieldPreDecrement/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/ForFieldPreIncrement/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/ForStatement/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/FormControl/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/FormDataField/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/FormDataSource/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/FormElementType/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/FormModelElement/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/FunctionCall/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/FunctionDeclaration/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/GlobalOrderElement/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/GreaterThanExpression/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/GreaterThanOrEqualExpression/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/GuidAttributeLiteral/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/GuidType/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/IfStatement/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/IfThenElseStatement/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/ImplicitSelection/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/InExpression/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/InsertFieldSpecification/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/InsertStatement/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/Int64AttributeLiteral/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/Int64LiteralExpression/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/Int64Type/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/IntAttributeLiteral/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/IntLiteralExpression/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/IntType/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/IntegerDivideExpression/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/Interface/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/Intrinsic/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/IntrinsicAttributeLiteral/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/IsClrExpression/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/IsExpression/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/JoinSpecification/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/LessThanExpression/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/LessThanOrEqualExpression/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/LikeExpression/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/LocalDeclarationsStatement/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/MaxAggregateSelection/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/Method/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/MinAggregateSelection/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/ModExpression/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/ModelElementUsingEntry/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/Modifier/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/MoveCursorStatement/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/MultiplyExpression/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/NamedFieldReference/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/NamedTypeInternal/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/NewCall/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/NewClrArrayExpression/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/NewClrCall/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/NextExpression/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/NotEqualExpression/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/NotExpression/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/NullLiteralExpression/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/NumberedFieldReference/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/OrExpression/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/ParameterDeclaration/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/PhysicalAndExpression/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/PhysicalNotExpression/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/PhysicalOrExpression/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/PhysicalXorExpression/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/Placeholder/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/PrintStatement/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/ProvidedType/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/ProvidedTypeStaticCall/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/QualifiedCall/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/QualifiedField/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/QualifiedInstanceName/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/QualifiedNumberedField/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/QualifiedStaticCall/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/QualifiedStaticField/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/QualifiedStaticFieldExpression/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/Query/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/QueryDataSource/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/QueryDataSourceHaving/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/QueryDataSourceRange/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/QueryDataSourceRelation/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/QueryModelElement/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/RealLiteralExpression/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/RetryStatement/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/ReturnStatement/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/SearchStatement/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/ShiftLeftExpression/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/ShiftRightExpression/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/SimpleField/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/SimpleInstanceName/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/SimpleOrderElement/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/SimpleQualifierInternal/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/StaticField/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/StaticMethodCall/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/StaticQualifier/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/StringAttributeLiteral/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/StringLengthType/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/StringLiteralExpression/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/StringTypeInternal/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/SubtractExpression/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/SumAggregateSelection/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/SuperCall/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/SwitchCase/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/SwitchStatement/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/SwitchStatementCaseEntry/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/Table/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/TableFieldDeclaration/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/TableLookupExpression/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/ThrowStatement/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/TryStatement/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/TryStatementCatchEntry/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/TtsAbortStatement/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/TtsBeginStatement/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/TtsEndStatement/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/UnaryMinusExpression/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/UncheckedStatement/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/UpdateStatement/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/UsingStatement/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/ValidTimeStateDate/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/ValidTimeStateRange/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/VarType/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/VariableDeclarationInternal/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/VoidType/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/WhileStatement/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +build/extractor-tests/XppTypeCompilationUnit/MISSING_SOURCE.txt 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 9e853e0f3fa6698fd4a0a627d12381bfaa1611b937209e1ea9d2208ea6e6f2b3 +lib/codeql/xpp/elements/AddExpression.qll 4a2fcfc5d20e3da098d36bdde90fad74210deaee632b34e7e770c7f7f095bd6e 02f87dd7605bb75997fcfd99872b744bee767f5b06719aca52702134cb394760 +lib/codeql/xpp/elements/AggregateSelection.qll 8c725200e127cb56d2ee7cba81fa65a6577281e46192644c4142f04ffb1ecfb6 8c100b00d8efb047a03731826846b2adbfbda52a49e23a4724f1cef981f87d80 +lib/codeql/xpp/elements/AllFieldsSelection.qll 1a54382e3c3518a7f9a868e861570591162adae4c18cef936b504b8cd0d80054 32a7bdceaee25928243b99db1b0c21534cbb19fd03dfe24a8a7a69414d3ba4d7 +lib/codeql/xpp/elements/AndExpression.qll 9941d3238a0d9ff998358b41647116c2b018f403405f739706b2dd59089db082 fb241e31b932f8b54352e075ffd64662845600e93b67dae1b8316a2eeccc6e85 +lib/codeql/xpp/elements/AnyType.qll 0252091652b7a6c86e848977abf4a168df84e64cef0dc9fcf7ed7c223f4b6bb7 e800100e6128d5a14a0dfb84eadad1e6315e3e61c2902ff431ad37f6c6ae8945 +lib/codeql/xpp/elements/ArraySpecification.qll 6908234dc70cbc5e46d1e99b7474cd322e5d2541b44593b178b9ae17d1720280 6f4e069aff2631a51705026dc9c1e29f34bba2ae50ef88f1be18a7086a3a3e0c +lib/codeql/xpp/elements/AsClrExpression.qll a21094b288e821397c30b3b5c9e70b2af8f4b67491742776d5fce648bf911f91 0b1bf3738fc8c154fa7dd6da4048f8b00cd9b62f5aef99c3f9de11e83fd60d62 +lib/codeql/xpp/elements/AsExpression.qll 862d978bf4754ee2de86549c03b8e6aa3c6fd5d4560337edb2e25717c6a27548 ddec4917416336dd0106fb5ffa927557a9cdde9c83fe8af7a86b10d006b90db9 +lib/codeql/xpp/elements/AssignDecrementStatement.qll e0955f59cd758030994429d247a1f6a89a7cc66c260bb0c12e8814da549f1087 c1c0def8ccb2d9096df99df9883d980251d5bfcbe8801fd38be793021e5e9b6a +lib/codeql/xpp/elements/AssignDivideStatement.qll 00e8e2b04799b6b6e3a4af0eff43eb5e5b6f238bcb127de93ab49d9e0694e521 b2166e1b264c8d559a3195406a5273e725e6778e8c75c669fb4529025c10085d +lib/codeql/xpp/elements/AssignEqualStatement.qll 8ed104b0003c372d9c0b885267b43654d156d456d576ba30cc17f5de2c964b0a 816588a8d3b6d60d36ab455f25ae354751a8080f937f24ffb7e75336ed2e691b +lib/codeql/xpp/elements/AssignIncrementStatement.qll 3377d384e5a44230940816376c5d4fd50e9ea0d1fe85e746f486ffbe1c95d7bf eed9b49295fc9985e2c46b2d670ab1e326286487724f0e3c14866ec5e20dc470 +lib/codeql/xpp/elements/AssignMultipleFieldStatement.qll 9ea99074e0f0c93d53376e72b665e97f4a4b6e0f17e10741a5295dcfd31b8c17 2c7848ba51494b58210c149dd50384f06cfe8327fb15b275ec3374924f3300e7 +lib/codeql/xpp/elements/AssignMultiplyStatement.qll 9b972fa75ef8de4d076100a595c2233a50e81dbe3e4c0e72829fda095f1f4f22 2ff4f016bea3b54701a98af8069b8528e75bfd6ff0a5438041974606646bdfff +lib/codeql/xpp/elements/AssignPostDecrementStatement.qll f636e0758f4ce0c256618b3e5c17c9ba72d18a21cb742ef9d6427baee3facd21 603a00761cb279c43d6e563141b3f4a494909630c0930b61546b2df4bf2332d6 +lib/codeql/xpp/elements/AssignPostIncrementStatement.qll 1c9ea3a429df0b218f37b46ac8001b70836eab82c38b54d4a890d858439a59b1 c96093b6ce3d66e14e95a2c90aa5b68cf9a5383bc05d44b9395147e12050f031 +lib/codeql/xpp/elements/AssignPreDecrementStatement.qll 1c5c063f05e27cf953338d4469bf1ab26c8e43bb0617a2ae29f7bf45700fd291 1d850799cb1674a611a89c153e6d92e87e03918a10bdbcf55fb8b3370d686c8c +lib/codeql/xpp/elements/AssignPreIncrementStatement.qll eeeb97dcf464568d0a893a285fe156d5c1efa65caa1784d505e985ad0e815429 87076b7e65f44c64227b2d6e40e27d41086a77f269dbcced55bfced1093bcff6 +lib/codeql/xpp/elements/AssignmentBinary.qll 9137c9b7a21bee6859bc83f0a8657f670360a3bde979638f2a73749aaf342b2d a4d37e442c3142953b371303cfb1129c3c04643a5b500652f71d182eb0b85d73 +lib/codeql/xpp/elements/AssignmentEventHandlerBase.qll 66db6ee48cd71eeddeecb04ddc4d17559ca2b3c264ec488d218289c37138f05d 03d1db37570909610ad70ad4644056169fa157aa1c31b88b2170ef49380872fd +lib/codeql/xpp/elements/AssignmentEventHandlerClr.qll bda5f01e5fc052f4783a9f5bc552821f6257e488beeb8534f3c9029a98d5f9a1 910df9b2a745376b8b076d5950769fe5a7d91b8b441090cebc51b1cb365d73cd +lib/codeql/xpp/elements/AssignmentEventHandlerInstance.qll 5ebf7f274714800b578cd8055a952506e7ff1457e007f96f563d2b3cc1ef0f85 7ada7409d0936fa0e4b3fa582fb6d86ef3b95256e2e84cb70a0e5a072aec866d +lib/codeql/xpp/elements/AssignmentEventHandlerStatic.qll b8f1b1013357a93552a7ffdec2252b84ad8c87a12d16c325bdf485ce55732082 bb5053fb1679f389e17ad2bffe87f4505ee3ee5d9408d85c9cd2fafd6cc983b4 +lib/codeql/xpp/elements/AssignmentEventHandlerStaticInternal.qll 664135577c25abc8997f0b96c205c8e852e2a58eeabfc9f930dfcdc49bc8d25d 42b65c41660566fe38a1c7b74d6f2f26223569d83f2106cd7dc2dfa197425555 +lib/codeql/xpp/elements/AssignmentSingleField.qll 225fc3727f1758bb5b6c6f1f0784fb70f1b0841b7981e18353cf65a06683fbd2 c3a7536a4afb9db0dc9c9f241189dab88681c5ce7b669b4ecc5930ea3ce6309f +lib/codeql/xpp/elements/AssignmentStatement.qll bce7c66f085cae6ad34a122eef96d0825f23836d934e2b42c1b961cb12f92270 7f3c5eaec2442897c560c630855671b9ba88045a498b34cc6526537ced4bfe2a +lib/codeql/xpp/elements/Ast.qll f6e1c68f19bd58d016123c8da3e6ee5af88ee4da0a0e01f990448a213134a6dd 2bda427c22627af377fd73afb48f566176c0d5ae60de36f9e3d3be154c6bfb59 +lib/codeql/xpp/elements/Attribute.qll 13ce52099cf3feed87f4bc4392f2669c1c3cd080cdc7e2e1884cb91e9d16c10a e44daf9be5e23b4d960fd3a688240db903445fcdae5f760a2464b47f154b7f00 +lib/codeql/xpp/elements/AttributeExpression.qll edf5e60515e57ddff8702676efe206200c2a0b6b75d16c936770f2bf928aacb6 130a74a142bfa3b38149ba68c99a76d8986a8e9d187640096d5a2df6e36d47d8 +lib/codeql/xpp/elements/AttributeList.qll 0156c0fa00315d72d741c7e4f4888c73be82372e1d8fac2cfe3529f95239b15a 9baff1d4203382fa24d3f8acbd8b87ec3cfa3d0e0e7b82d606d1c151241660c9 +lib/codeql/xpp/elements/AttributeLiteral.qll 16015eda1a341764dd4421ff9281d32ad039f44f983536ee9595deeede2161fb beba992e7d4379ec2a2639ce21d774a2d2f0e8719c604a20ddeb554cc22ea967 +lib/codeql/xpp/elements/AttributeNamedParameterEntry.qll 8194909058113ff653051ea32365b73cd172367beb41383ab304a4925be72da0 6b50e29c9ab16a0af6b95222749ce0fb9ba1f9d80f5b9c85771fbdafc0350619 +lib/codeql/xpp/elements/AvgAggregateSelection.qll 81ae351aa825f0bc702088387ddd4239fcf81b47d4f51aaf07fd3e8eb80fe843 debdc90c877d1c0886617857f7545ed1439e777c42af098e98a05b07fefec539 +lib/codeql/xpp/elements/BinaryExpression.qll 0e19d543b4c76a6922d328ffc55fa2c52bc711f873f2fd2a270968514a6f7acc 2a3a87668ae6c6e54a336fccf413849f7289d9e90dacb7196e9887729db82e11 +lib/codeql/xpp/elements/BooleanAttributeLiteral.qll 0886f9b43acf601395d431475f2cdc042cddf2224ef60756eb3afc40d5036b68 6ee86417d80ff7c0c49bbdd3f12889f90297f3ce882312cd247bae210bab77f4 +lib/codeql/xpp/elements/BooleanLiteralExpression.qll e373db7b055cb7f2f975c02549d5640346c05ee7a8fb65437764f6213628a797 704e29e3fb674387622c1dbb19ffe4fddcf851c88248b0f5bcbcafd075bd661b +lib/codeql/xpp/elements/BooleanType.qll ac6f7a5789d59ccdff189402e284a07fc259d1d7cf2ff57329165460bf638c78 0798eae1a7e0dc339ca534959343815cdeea0d8351e01deb06fd1c5c5dfb7841 +lib/codeql/xpp/elements/BreakStatement.qll 5726bd833eee06e426f1c3aef52b4788f6f82c8218b85ad10e0d697c8c026952 21a874a3415b8661eb6249169cddb5a9acac0781c075a8f8a31e6dc8e9f60e51 +lib/codeql/xpp/elements/BreakpointStatement.qll 346d86c283fc093e3f83e1e393ab2221b60ed201fb2274562db56cd7f1ceb0eb 23406db52697cdcf1c9f0c09b6413ff8add266ed886527b2b62c092731fd2e22 +lib/codeql/xpp/elements/Case.qll 651f317d244767a6856df55b996ec055d107350b8cf4ae22f0461537f80f2485 4567463a03de594bdb3f87f84c5a336155c87b6d991f672354a9e93be1e107b1 +lib/codeql/xpp/elements/CaseDefault.qll 6352988567ab8396333aac70c24e11793e0e7fb8fe4eedfdedaa260bb1ab3846 bc13b35994276015d03a37f5afb43a6e013b43bf7227afc7b9c2fd6ffecc0fd6 +lib/codeql/xpp/elements/CaseValues.qll 37cd9d36ba5710c1c3c4050ec81f785f6c07b8607040943e45ce90a6191373f3 c6db14d6279d9fa141aef388ccc74cdccc072cbdfb46e5ae3b7c4120732b0c8e +lib/codeql/xpp/elements/Catch.qll 630b63790196a9ab570143e185f5cabc926aa4121b691e497d5d2039b418c5dc 57eb36423c35c1b5cd4b4d379de54b4ae8ac4cddb737aafca2ffca077f5b7966 +lib/codeql/xpp/elements/CatchAllValues.qll 6f50e96cd6988b51f08134cf6fc11da6feac474ee4b60be68e4f4f922c3a4966 50786653a51e0ce7c8a8819f6389a0aaf4877cabf539d7387853d638dc3e9eec +lib/codeql/xpp/elements/CatchExpression.qll a883545ea509211f27dd5a4903a9a3658fa1ca7cb6c94e94c1436b1c97f070c6 23c5859a2e658bc66085fef42d2168d170b94f58ba3469624b70f0e7ad894a83 +lib/codeql/xpp/elements/CatchUpdateConflict.qll 7079fdfa1e06f1d275a4269477973703da86e80d2748c91ad4870c9a9fb2fa83 cb0c351c2f59c797d37548ded0d1b13109dc55bcbf7b6a13c89acef6f7b4cbe8 +lib/codeql/xpp/elements/ChangeCompanyStatement.qll 95e0c25a4148e3a8a3c10c950b5e3a1d0ce739100b2c516fce1939ce90529c75 d2514c2b957a44ffca4f21eaa96d633da87dc5e70a324ee11eb9c283a4deaa54 +lib/codeql/xpp/elements/ChangeStatement.qll fa67234218ffebf377d8c3e89024dbe8d9679c4cd9af6f7c8121823081bc3743 20c7166da74d37b0cee85287507b67cd4c768bd5b4de601df2927c2ac6db7c8d +lib/codeql/xpp/elements/Class.qll f9c009ddccac77888bd7417569fd84fcaa8340c2bef3ca16b9a6df6eb64a4348 aad7d3a7a4265ff9eda385a3c84e1604760258abb2c2318c242505297c2afd7e +lib/codeql/xpp/elements/ClassAccessModifier.qll 708cef471f29ffde3860136bbcf04dcaf6b8e242779b1279481ee7316fbbb5ce 5d6f1e57287504fb69214662cbdabb47c69e52f0cf48e6a9da8bfc3c20d334d6 +lib/codeql/xpp/elements/ClassOrInterface.qll 258185766556092cf0967a1844905e43199bab23bd316cdab10dbebe2cb085b3 a0578ac7cf8f996afdbd7449db5abc13367d975414ccbb7ae9f67d1cf8e471df +lib/codeql/xpp/elements/ClrEnumerationLiteralExpression.qll 2afb3d8bcbbade61f575fa222823c7855568533b7f147254dcdb1f9b022ec609 b718c2271ed84c161c23acf9c635e43aa95061053b7adf3159f78e244d0d7328 +lib/codeql/xpp/elements/ClrType.qll 85d0708c0b13ac3c4068675553c67608f54f76bbdab60d530def2e1c7dc96612 4529a0a5b100bf362011797e1ee56a85e5321961857b5c378868be61af1b9545 +lib/codeql/xpp/elements/Comment.qll 26bfa2b75062825c494ececaa7b38483335e1f6a576193434e5d49e555678bf5 f5fa402fc3c59c8f5449243bce3eef46eeb31acdd725963effc84eefe9c72a13 +lib/codeql/xpp/elements/CompilationUnit.qll e0e35d895c2832f096efad55e40ba3604101f62632ef86914a5e3f2b39334bff 16b7e05928499bdab56d4d99040e94e91f99d92c90f39607253c10c477bcfece +lib/codeql/xpp/elements/CompilationUnitRegionEntry.qll 882cdcfdc78e4febb2ca8c5afc29d7f06d9214d87033b4cb790f27837e44b627 26fe52e05ca4665afbd6da49be3b36522b4ccbef3daba23bda0f73737738a5f6 +lib/codeql/xpp/elements/CompoundStatement.qll dcedda1b0e9c7ed05e3e743bd9a2d6ffc42bbf6ba82c7b4391a52e19bffcc993 f3aa6f7d3b1c0381f3ec3a1bf830e458be795ad04cab5f6e68dab7d2cadac0f2 +lib/codeql/xpp/elements/ConditionalExpression.qll b702c082fd5ef8b1a9f7bac0aa83cddf72447189853dea7c7e88141940bc55dd 8e9674f965f5bd1c5284f356f52f3abe3d32d95a63f85ca83ec0c230ef921737 +lib/codeql/xpp/elements/ContainerAttributeLiteral.qll 8480eee674488d5151c172581af081f667ae6a1c75b7497a68df59e5c70764ab 3cc814b198af5d5240dfcf15a0ef88278f71942723c73b3052cdc3466ba23f6d +lib/codeql/xpp/elements/ContainerLiteralExpression.qll 79c5dd1a0594b8acb6d18b88682a9b0118943f3e761ce5badc1f31c959b51657 a1dc4906bde47dbbdaeffbdf12a180b5bb312ab6ad8c09f6f85cd65cfbfcd4c0 +lib/codeql/xpp/elements/ContainerType.qll 3271c5f8ca67a8e12f1f5d14254f3f90b6fb5cafd24340450429f2f683759beb 015bba8ca8d37b5d430342c5400770286a547b11d2db3eceb713f1f1dfc9b35d +lib/codeql/xpp/elements/ContinueStatement.qll 424424ccb01ee45c494aeb0780067d3a4df042a8245131bbcc2bd77ae584de0c a028f2b62241a52926ea3eb6770919f389e66832c4b8a7ec098eb2d83a41efec +lib/codeql/xpp/elements/CountAggregateSelection.qll 5f1d29b97a63e9df9362021bb12dca9f0d9ec36ba39238e1f5d3f6f18e29e070 0ad30c585bf1f94047aedbdb217e6051663978f8f2aa6bb9827cb4b99a0df716 +lib/codeql/xpp/elements/CrossCompany.qll 86c99583ee23a945cedf95d4ffe25656204ec5d44b198ccff7f8e24f00351fac 7f0ea00e7a988288e12f99fdf374da2c7caa3d7cbd8a17a5756586f239800bcb +lib/codeql/xpp/elements/CrossCompanyAll.qll c9477a25398c37e65a87eb28eaaf9e7623ae2b8d18da88237fd59eaa57a5a458 1f83f443ef5d5b8fe0eaadd907537025ba34ab223cd80d3ec714b75c2bcab704 +lib/codeql/xpp/elements/CrossCompanyContainer.qll 2cf702549961f1dbbc8a2cc969f299ceed7d0ebd18b3292aeeb5f15647c44b7a 185ccd56608e0912f7cc203af2ee5353607160d26b436e1a6d61325faad49db8 +lib/codeql/xpp/elements/DateAttributeLiteral.qll bc056b684374ce92abdd1f602841f7cf873b33091bf2f52931d10ec779255982 394d06469ce0ad797844ec38bbe4802ca8cd4eb6397758134c610ab6860a8cd9 +lib/codeql/xpp/elements/DateLiteralExpression.qll 5adffbab2818a85fd9777d6cff0f81c6d6e67324e3c2e7f617bbc22d2a4928e1 1c4da25b79095f22d9482cd95e84ea3db0f5f1b2b37a58f4846a47fe7d712441 +lib/codeql/xpp/elements/DateTimeAttributeLiteral.qll a63214951dd00a2691e249e85056c67a5158cf1b5090df71111cedc5c24f9ee1 b80e0c39967fb79925ee57508c7c00fa0fc9b342ad679fc93f1f373a240d3db4 +lib/codeql/xpp/elements/DateTimeLiteralExpression.qll 7a287bfb30e04058de6c55388cd575dea608192642dd2b242233b385c7a9680c a510b865481a0d06dfb8c36e797071e73698c057926c0321e7e720254b78eb35 +lib/codeql/xpp/elements/DateTimeType.qll 86485bf66e5197a2b5c63a276ec4e093cfeefcb5eb9784afbdeeb5912939131f 7985f6dc65f4d75756d69f30294c894498c5fc093d2f2661012cbf8bc06f16b2 +lib/codeql/xpp/elements/DateType.qll c19a24f4282007848b1a288b0f314b9d4e30c049ce45be0c98a91d68de81a1fd 2095626145c00b8a9962d35f544d437c048743b863ee4b71e8d1a5d6169b610b +lib/codeql/xpp/elements/DblAttributeLiteral.qll 8e277df503631685f9108070684677add4b0b7618d47d5424f3ea457f7e31c4f f77129613525f0ba1a6fbeb7b767618df594a551fd00bebb01a28ab187605ba4 +lib/codeql/xpp/elements/DblType.qll 1ff28d50765fd0c23a2fac02d490fdfb5753c56081b4fb35cf25034fb0e89d17 8a1212e87117c1e70ed9447f4f2083b235729c2b11ee2bad584f19e8c11eb0c9 +lib/codeql/xpp/elements/Declaration.qll b32190ebe8ae34c24512ec09c317a23b742b0e47db3e17033e4240787ef9b33a d5e5796d8ae0188cd203eea1ec3d43c0ad0e8c6210d525713a5690bddea0e964 +lib/codeql/xpp/elements/DefaultTypeAttributeLiteral.qll 2b06f4bd9dbd0de2c9caadf7e4aa4f8a59ba1d0e8ccc3231f6976186a1435e49 c386231380841d2bd2609f57758c576acf2a64e12f8065555d73eae0ad86be1e +lib/codeql/xpp/elements/DefaultTypeLiteralExpression.qll f487831ece0e4ba733bcb2b2af4c6a838c1a0a2011cfc52aaf4fdd47751f61e2 ac84a662ea36fe76211ad0b34e93a45bbd10c2e97e61ce52bb47546eeb3c517b +lib/codeql/xpp/elements/Delegate.qll 265cf4f80c8f125f112c7b41b8fabbd6a06d1434278d0f99feede3f0cb6d805e 195dea66f5665a621e4ac7505bb47f5febf3f3ed253aa56bc2092076206c46d2 +lib/codeql/xpp/elements/DeleteStatement.qll 9af866a655cf76578d1b3a40720bec9b9a11e7fdb9be9d690a7997769d1e30fa 018eb116a4be8e5b12f9388a89cd8869fb18e695da269cde8475210a9aff1a45 +lib/codeql/xpp/elements/DivideExpression.qll 7a7d9b10872181b06dfc9aadef022f8fa4ce3556004f37fc70a0b68a19a82d0c 53cd105670ec028ade70f0b8307f62ac2832bb2f6791fc997f85037ef9dd1752 +lib/codeql/xpp/elements/DoWhileStatement.qll 74677d1b0092bbbd8d7ce18a825685addb3b2714ee13ce44e87e486852ba90a7 3a190651c40ddb0c3203cfac0a2aebb2a0aaebe3cbf72dddf5fea7a8708d3e33 +lib/codeql/xpp/elements/Element.qll 8980f558fc91474ef3815319d624f83f4fd756547cd6b72a31761d988e120c29 7965ff0ad0879c70f3b9fddded3bf0ff01f04795064a0f2ee6f7806b590ddd71 +lib/codeql/xpp/elements/EmptyExpression.qll 5f1f9bbb17ed14570bf379b4e867fe3e6e3920899a2acc8902dcfa1a2ba9d354 e6960cbcf67e3cd86992881111942f5a0190e88bbb7f931f065d26811cf98f58 +lib/codeql/xpp/elements/EmptyStatement.qll cfe1f14249ec5b3966ee5564d1179cd3a6de8e312783574de34c2aaf91491abe 10192cef4d5d94d6090ee69ae56fe7c42a6cac21877f2f11ad6dc8c4b45d7dda +lib/codeql/xpp/elements/EnumAttributeLiteral.qll 36e2c605af4e69cd497392155b84adb19bc451362cecccfd920c42e43ca50c9a 5e95054d00b61ff3d264f0e448bd8e65f5a4a51abd9640bcbd72173c32b112d5 +lib/codeql/xpp/elements/EnumerationLiteralExpression.qll 39ea519a3735db2edfd69dea3a44cdc982eb829212b12c83e6b0a0dc45fad486 0afb7525eb83a64184e1b039f14850674525cfeb802810dc07e3e37512c541b9 +lib/codeql/xpp/elements/EnumerationType.qll b318f00a7b5dc7f2d8783c4b7e1b727cd2cfd8382c2df4673ed99e510cafa81a 8ce0527859849f93261377bf1aaf3877d261fcc3bac7af1049118e26dc881f04 +lib/codeql/xpp/elements/EqualExpression.qll 3b1e20cc40412d4679e4299468afe53ef2b637d4b196b3101453ba2b1d486822 0b776f8eb5d1c7c457ac36f36591ae3a582cbd3112f3b5674c681adc3391710b +lib/codeql/xpp/elements/ErrorElement.qll e7a7bcbff007f454ddefdcc0ca7ee89d8ce0f0f282f736e461b0ca9b06f13b66 ae896186bb5506269c9a94d921d022525b43821e1a721db15e0e67075aa6e4ec +lib/codeql/xpp/elements/Evaluation.qll de0079b53f2350fbc91b22f31df6590c048faa8bdc28ffdc7574fee35cbe94b1 391b9c4324ce33e9c84659166eff0d12a4a63ed5f71689326a2602dfdc8db069 +lib/codeql/xpp/elements/EvaluationActualParameterEntry.qll 9847377c879d0aca9487841458223b6dc3ca731ac6576c64606178604a61b946 afa25c53dc65325ae40a837535d34b6a7b2a948b3c2f43869aa86c66abd513c0 +lib/codeql/xpp/elements/ExplicitSelection.qll b5222ab609a3b3dd6a3f22c4c8006fef9b458ef8173c6da1ff681e2a51d72ae3 79de0ee9f40c554a7a39de97d24315c3e9c975be9bf89f5fa95942ba0ece7046 +lib/codeql/xpp/elements/Expression.qll f1c725a263880b716efd7ef6dc0aa1721047f75114992cce67647a420ddebc07 64b5cab236b6ef9d6951c2c0930b7c2a70f5e5f3f192903129381a4eb78246bb +lib/codeql/xpp/elements/ExpressionCompilationUnit.qll 5734b6182d244c00a25a073757401304d475bccec28ba0650163edb345f06f5e 3a011aad61c8de9d1b8dac0601ea5f81ae438be157b7618faaf17d1e0d5c39d7 +lib/codeql/xpp/elements/ExpressionQualifier.qll 3d58b95a1c358d12a8ee11150ba59bb115052889a2faa89093d87766ea14b7bb 03c991120db57b572c12e423bd279e75d9b57b86de440f0043958fb4ab17961f +lib/codeql/xpp/elements/ExpressionStatement.qll de263c83bb7cef4a9f3d87b18feae0382b79bfa96fe220ec7c365a9c936ab90e 67ee508931b1a6d0852236ff3746de62e33aa5f766083c335f141618ea8f1045 +lib/codeql/xpp/elements/FieldAssignment.qll dbf2655dac08be71a88260319d9c9e22baec8a81abb26e3077ab5e6e51a5ea09 351fd15b8aa252cf63cc1717d9b405bd4c15e833a75384a7975a43f4ed9bcd3e +lib/codeql/xpp/elements/FieldDeclaration.qll 0be6a87a2b192631b96ec0e22bf75b6805b9415a54becc500f6cf891f4a3f236 ed9b78070c19971dd96270a6f7fca2a757328c9a33a6bd3570a794dcff9d5abb +lib/codeql/xpp/elements/FieldDeclarationInternal.qll dc77de41ad054cb20466b4dec96c7028fb0303449be6ab5a7e9c6f86f9000ed8 ff89f164844422e60873f409cad2600228712e25b5312a3b8ecf04236d3b41b1 +lib/codeql/xpp/elements/FieldExpression.qll fed666d59f64328b0e3de9a5866890e70f047208e243fab34a24f506d163473c 40166f0d04f5696fccf4fe9c81046949d20c3bcc2860425f99d51cd668611288 +lib/codeql/xpp/elements/FieldExpressionInternal.qll 2b23ff18b991a69ebf5dd2c61a67a64ada939af2296f80ec5acadc9e7ef3ff8b f8c809cf4928ae600c45d58f40a5860f40680a71c957e4ecd9a7a29e10c9280f +lib/codeql/xpp/elements/FieldSelection.qll 739d814b543882db5039d10711d1662462112e33e39a523952e4b316fde27fdb fe522a810c61d8f32a4a65812bdfb7ebfd3b615fece34ede1eae49b63a9c041d +lib/codeql/xpp/elements/FieldSpecification.qll ab894802cf3eec8dd9154d9b1276174bfeef8f730400e5b3ae731686323d9fab 0fc63a8ecb4f4ccb8e66b724e020c5b3d30c0943731753eedcd4c10788a47e23 +lib/codeql/xpp/elements/File.qll 1e8f1090a75119ff901726e1e17a26f3c9b7e08abbac571fcb40ea48da2fbabe e9450963f1dd433c276860dc1963efcd7ac5bc76f344ec31eb53c2b54e792d95 +lib/codeql/xpp/elements/FindStatement.qll fae58b73b34a595bd159d77740fb390605a6500a65df7d3535416196cf68d2b8 48af0872b666aa8a558406f5af7fb1cf4f62aef0c0243c9d3db577b85cde5dbc +lib/codeql/xpp/elements/FlushStatement.qll 21a730805cf4a72cde6f2d683d86f25ed05ba0cb49763d16178a134453e9d660 e6250e6c091cfc2a45d8e0847e7868f3c9b09c9d257976a722582e237b1b7d3b +lib/codeql/xpp/elements/ForAssign.qll 15aba229f56c39335e41be2054974dd94aea52c0533e8ceca052eb68d37a2556 76122a394fcabfc9d7a0b4fda293c2114533c88981513ae4069912106a01b103 +lib/codeql/xpp/elements/ForDeclarationAssign.qll fd18e4dc636069db168452721b1671c5d19369a87ddfab60f2d74df8520c2edb 13869324f38a099c11e7a72b74e821ce05c5b3c98fc7dafefc01d0758390fa87 +lib/codeql/xpp/elements/ForExpressionAssign.qll 71a2deb089dc9a5811ebf57c3823f273e58e83b33011c8ccb8b5b56823e080e6 eb5620abcac20cb93a5d7b48a35db38f648dd0796d9750164d2001f33c3f5cfa +lib/codeql/xpp/elements/ForFieldAssign.qll c97cbdadba3fd64de2c3d3df502cffa4ecc0edc37053a63a4e4f4f665174ebb2 bb1daaceea4d6b66779bcf11ba6ba77a99e6155b85044663670e4d086d440a68 +lib/codeql/xpp/elements/ForFieldDecrementAssign.qll f1c0ed208a07a10cda7395b84fd75ffa05757dc6bc008557eb0572345e3d1509 0f39f0b7ddebcf27079f9d21bd8b963b6d6fccffe9b12910e13018bf067037cd +lib/codeql/xpp/elements/ForFieldIncrementAssign.qll 3d96fdf71b841a9867cb49ff5649b8564c1b500ff328cbe8d9af2bce18ad8b10 ab6ed5abb19bb2fe0c64035e4f2d047dd3d4fe6a16bc056c7790097e5c401139 +lib/codeql/xpp/elements/ForFieldPostDecrement.qll 20343037c9ea9aac5bed298ad3aba237b9b5c7509f01b1f4436dde345dc278e4 71af75907be9578c06b6fbd1f361a39a5ef7645327e187703d61dc63fcb0172d +lib/codeql/xpp/elements/ForFieldPostIncrement.qll dfa071b6255c8879850849fb818f2dbd749c062c962d3757dfb5eb980898bf43 41954f98d17c43d9966d82e8410b705fcae02dfc6b933506a52a02afbf854b7a +lib/codeql/xpp/elements/ForFieldPreDecrement.qll 9a525f77b6b3437099cad9c786154cf9096c21cb61eaacd9de3dcaee450ed052 0b377cc327d6ebf56a8abf74f0e51e2882115f56537a032921901488dcfd1679 +lib/codeql/xpp/elements/ForFieldPreIncrement.qll 0a72033f67d6f3c65b923a90120bc2206953cc7584a49039b109922f08c6face 5d9bdf63419b26e56ba131fd04ca184d3a22fb3065c0629c7d4486b6a02befee +lib/codeql/xpp/elements/ForStatement.qll 9f81158857b9fedb80a404eebd92a071fe89ac80f4cae156222da6105223deac 8895b41a05ad0d647cb88a1ff668283b5b2a60e6d448d1e99fe3d116aa45a2ba +lib/codeql/xpp/elements/FormControl.qll ac022943212f23b99282f66f94eaa7bf17ffa7745bcff9cd873d1d1c02e7a3bf e83a5325d001486afcdf768a1d50239d79b46c763661d036ca334689168f2316 +lib/codeql/xpp/elements/FormDataField.qll 0399bbaff4b6ef08fb9b38df3794c5cd14fbfea207f1dd4d116077ad814f6e48 6cc6a4ee11fad1edac9f6fefabd36db895bb5bdc349f355353f8387a1f092125 +lib/codeql/xpp/elements/FormDataSource.qll c2352beb6926fd0d93247920343d516ff8035da7f9b37ed7e7082e088af16d50 5f150494563a02ae52dbc7e4b8f94033e3028c2c3d42274a8af02cbcec32136d +lib/codeql/xpp/elements/FormElementType.qll 8ffce7f911b7708a13a2d0fa55d73d1f7b6160c582f45a59055e0bd82b2b6b25 ae4bdaaf08c0454b11e170294c1ea55d795e5744d56ee00ae1ce9c44d011e1cb +lib/codeql/xpp/elements/FormModelElement.qll 180c020e38a887bb2ab4a17b6726c68de84c12698be6bba34d9d0f18f1d10595 d5306c78ec115dfe9fa54ef522be645f5f891426d25ee0b9d683102f4ddf605c +lib/codeql/xpp/elements/FormNestedElement.qll 3d5428970d520688b00691c98f501d801ba2dabcec23945279d84d3a31dc489a 4c561b855a2eab389cc8ca5e23d60a6525582fc2fbb284548ea15993535fbef6 +lib/codeql/xpp/elements/FunctionCall.qll b4e4fd99728bf182558ef20844a59f15ff25770e084faf7da8fba5ac247645fb 419e85d4adcd240e152135124cfa7fa0d8fa9fef485ddd710cca778f38afacbd +lib/codeql/xpp/elements/FunctionDeclaration.qll 4ca12749bb28c69074c5c16b5ac1408f386e9f87c5f9202c8af7714fde13d0f2 6f1b5fad053d137607a52956951051de81095aa2b0210ad55ea360c0d0b66a5f +lib/codeql/xpp/elements/GenericEvaluation.qll fc87c28994e21ebdd37f11f2f262ac2db239622895bdedb3d7ef58f6584f3f5d 785fda45859a5fef62560d0c08aa76071331291aaad25eaba862950d94a9a92b +lib/codeql/xpp/elements/GenericXppType.qll b711641b6c6f3e626bf922b97f3b4f285fe3b88dda1d9c0f1d889f24a2c80587 9458677e368117eb33cbc98414e84f34705532f7594386527e173c0b255a8692 +lib/codeql/xpp/elements/GlobalOrderElement.qll 27de07ea6cdf65216750a99be1e712cf04e9bffa946795284d6bda1ad62a3423 7943b50d0cbce4e0f473a0da19c19715dee42828c5a2b04819f3882beb0d1bdd +lib/codeql/xpp/elements/GreaterThanExpression.qll 028de8218c161f26c3bbec2676bc9d41e037c6994773e251b236cfc7187d29a5 734f9da3ea88ebb40b2aa5c45fb7dbc3e1ddc7b5639298f93b7012565656d7eb +lib/codeql/xpp/elements/GreaterThanOrEqualExpression.qll 6147f8e32c293349e7b3eaaad2b32f7e7170441712d2ac18616d8b4ea1aeef44 b3c94d9d06c429d97046fa5c282149b71c8f9acf2b60066524acef975434f06f +lib/codeql/xpp/elements/GuidAttributeLiteral.qll e07531ed5ca6ed009e02a69f7782048da6aa7c46c25b523008394237dac658db e7a0c9cf5d3ea921a11363dbdaeb465211be254a61b8abf7b9a3bced5b7ff7cd +lib/codeql/xpp/elements/GuidType.qll 010acd378abe3e95b87273b206737df78c69d3b4e7d776c5c2f9675dad096657 2ce3bd26d2aaa0c7b4eabce829920b07754b122e0bea6a2af3415db18407a78c +lib/codeql/xpp/elements/IfStatement.qll c83d9ea05644e34140c1294367662590469b8a49b9b4247294d6acd8fbe46350 b0246e55f2ac3b609fbc239434a5f1e50bed0bcab59972a3fccf9de014e6c83f +lib/codeql/xpp/elements/IfThenElseStatement.qll d28a1ffeb0d109f8cb27a3ea69b5c12a451c43c6551a9a5dd960402b478d74c0 458dd2ec155b9a2f6b114bf290e9f1b007891e279756f72d07a56f2a22946868 +lib/codeql/xpp/elements/ImplicitSelection.qll e9b5dda954db96c7ba9c024dd914fe5daa176ffbc00cbdcae7399a8821051e00 781f6e3e8220f1617ffddd725b5529947f98aea14a105843bee960fccd34ec26 +lib/codeql/xpp/elements/InExpression.qll 42354aef576209c0325f95c357098c0ebe8ed77d7f186473f7931840f399c230 8d1b59d2dc7b25a0d8d226748be820cdbb51b79b3f47b2fc0d414c31b75492d6 +lib/codeql/xpp/elements/InsertFieldSpecification.qll c7fd6d3da17b5818a6d147be745c3b8b2ccd30932647f519a6cfc9dbc568a59f 0c9d800b6629ec2f380dcd44d9cc49b811fa596c9b4335fe3e8ba6e462d03513 +lib/codeql/xpp/elements/InsertStatement.qll b81e3dd3a15bcfd5c58cd3ce79ffcb887e4f2c2b663130f242952a7689706191 44dc45d0b3e03d4fc46ad6e914910a3ffde4c019f8987ccd8ee1e73af1f30514 +lib/codeql/xpp/elements/InstanceName.qll 66484105c78b926b546036a7501677a3ed75574eeb06ce83292d390b791ae436 a0d92d4a919ac86969ee7fe878d0cff69c51e6f4e7135b0bc608e5dce4ce901c +lib/codeql/xpp/elements/Int64AttributeLiteral.qll 5707ae2be0532f04878f7c1d4cac3c4299019e890d405a1885a71d8c8d1882d5 7f729024ec835d7664bcf2d17d97d6895ac1de8f29502896e17814d42d686845 +lib/codeql/xpp/elements/Int64LiteralExpression.qll ac16a931500c412da1614d3301c1eb5d7851aa704ab5a96dd364346572539013 02dd7825b6fd7ec4ce4667c50129ec5fab6cc06b592d9cc2ff931d39ddc59500 +lib/codeql/xpp/elements/Int64Type.qll 52e6e1478e237c79352435beb6593a4b3a953acccac6cadd3519f5a90b8ea557 7e2d3f00a2473901421a2518c988841c6de880d0d8b1122ef670baf7cec7c337 +lib/codeql/xpp/elements/IntAttributeLiteral.qll 99d73d86f285ffc2746addc0295450e10482b799a0942b7ec00dd2c35fee0d28 49389a52735af49dcdcf7e38dfb1a06d6ffddfbbaf62a665835ec27f10032608 +lib/codeql/xpp/elements/IntLiteralExpression.qll f95d21a2e5b7fb9dc15f533b91845d3071f6cb060abb01ab8076a2a987af98ea 53c07b83005e4208587029f33bcf0f97a350c81c074431c4f164369ed409c78c +lib/codeql/xpp/elements/IntType.qll 9c4975a70c7caae2724851bc1e5b3c412034df7b11bf4aadd4db4168f56c7170 5c2f6964059deb954bda51b82a2c8790297c3ba88f367e00bf7027dde7b0b1fb +lib/codeql/xpp/elements/IntegerDivideExpression.qll 0e347fadb225eaab06701267c745ded537625efb6eb2096d2080c824e20e07b5 6f1c1e42cc0c5ba24970a1a46cec60918ce90bd2c33ceca8f2c3369373bb61c4 +lib/codeql/xpp/elements/Interface.qll 214177af2d98ad0c830225c637e5e5e3c4098023f4eee782e55c97eb49bd3aa9 2db2f00855c58130950860fd0218823e0ba296446723d64a4a64da9d78fa1844 +lib/codeql/xpp/elements/Intrinsic.qll 76730c665746f17d1ead289f883360ca98ec65a12ba84f1fe7fb1af4be8bb75f 0d1942d28a233ee1fa9a1d7049cf7c4d79db31e1433223df146d876c1f9054e9 +lib/codeql/xpp/elements/IntrinsicAttributeLiteral.qll 548ffbe3897f5ae75eeb95954dda76a6b5ae6da7b5a21905579e523ab0212642 47523ca78a5ec6deeabebe2c08ab674765c1b1122fb2e88d6ca60a4a82cb4a4a +lib/codeql/xpp/elements/IsAsExpression.qll c0c8354186c3ce860700813f50a83468776afd635a2355a57da55fd19524fa32 f7ff6395dc44f2aa5aaa76fac75053bd915849216674a1363d126e36a6c342b9 +lib/codeql/xpp/elements/IsClrExpression.qll 28f5020e980eb40b5a83bcff3890378f8cd871fa455c0e2de60626c42da237d6 94dbcf846f386b9225061d4b4f387385cdf99a5291a5ec364fdb7f8268512f29 +lib/codeql/xpp/elements/IsExpression.qll dd496510ead5dd0e1a7803aeab942dc89d5cfe228b1efc48ec0904601aa1c40b 429ff714ba655c352ddadff3d8f5615898e3354e3b5221547ee30cf9b184531b +lib/codeql/xpp/elements/JoinSpecification.qll d4b96852c376b81694c09130f16ce9c484b20208a5c8a732e8ae3d744fdef788 2eb065cdc662841ce96fc8947e975ab27e9875dbbd1e4cf1400c9e83d402d3e1 +lib/codeql/xpp/elements/LessThanExpression.qll 07bf760d0d7e9f949e09014380bf13253a249b70f0e15b791e7f493262b8993d e276b167438600f4c41032bdedcc5436d48d523062d201f990b29fe44263e3aa +lib/codeql/xpp/elements/LessThanOrEqualExpression.qll 2440c762fb2cc315a45823cef99c405ccb58c47471d4e57ca9e49c07316fe710 80caa4801147ef029a8877798bdab13d48241af81ae9f307dec4731e668ed7f2 +lib/codeql/xpp/elements/LikeExpression.qll 55a838dcd0d58b6f0ceb60a6574ac68a8fad7e568ae792ae180e8dfeebdef3c3 f2d6612d6342f5e1138f642d505cb26e96b7a338d69569ff9ebe628bda1b98cf +lib/codeql/xpp/elements/LiteralExpression.qll 11893ba88162652d1143aa5f5f834fce4af7ceec24adab8edc815aba4a55e731 f96f4369c0abd2c279d9e973d897c371b0374a3aa8a034eaacba428c9e66da5b +lib/codeql/xpp/elements/LocalDeclaration.qll 9aa4a9df8c3a88fc64240d6ed637163bf2f70fda05178260e351078b3aac52a8 4e1e97e1b8fd170ea931159586f9488d39a0c1f5f47374e3e731f66cda85bad4 +lib/codeql/xpp/elements/LocalDeclarationsStatement.qll 99c4bd95fd86049b0d539f25493a86ac9939f3fcc8baff549cdf00fadccec9ec d5c2060af7c16616144aa3f03942f884ab48e315d02e04db7e7c8ebad1a7a785 +lib/codeql/xpp/elements/Locatable.qll 3738d16b9d9db9eb586f3a07978c79059bb9853d9085f69b8e679a860f5d4ea1 d54425acc3c2d53b6f99f164eaef5f53520547f42505e8ec4c7c198af8646e5d +lib/codeql/xpp/elements/Location.qll 0a68fcbf8bbfa2f4c16e2e9c3ef89eb75b2698a77322b5160405a272dd861a63 859242550a7abed61d975a76d56ff01c2b554ccc54cc14120fa094162d1c2d73 +lib/codeql/xpp/elements/MaxAggregateSelection.qll 6dcbf652e7247c069e608062cd18721fc63a25c9dad315e6b8d6ee25342b7bf3 a962ddf7afbc8efa09ffea37860fa0787979c7e629846faaf3c6850923cbbe5c +lib/codeql/xpp/elements/Method.qll 04f67013ad1ddf127c79759a0a203e97974760dac5632a5857ffc16d5466c680 8675b4b0aa8b615824a697feb798c521a0c093e2388f190a8a10fcd493733e7f +lib/codeql/xpp/elements/MethodOrDelegate.qll 6942d828a825e642e1f531a2c60a79ce0fea0c4511bc47d095916195de5d47fc ca4939c9e415c13c11d2d0b73e0f4845e2f8d17b38fbd7757567288aeedfa3ab +lib/codeql/xpp/elements/MinAggregateSelection.qll 3a2aabd8df18d83033c90ff7cd061cd4c8f13505ee845e369b493bab33656833 f1492224972b0d4b91e90b57d18aab41d7523086b7e1a38216eda2d670aec490 +lib/codeql/xpp/elements/ModExpression.qll 75e59cb7e3a7ee950e30702904826e9166029ff371b15bb56e61ffc75656593c e79401d4ba1ac6c5eb8a62fc891cc92ca8657e945623da18e02d360a3d7f5cb9 +lib/codeql/xpp/elements/ModelElement.qll 8530785741f7965e8900cbba5be9078db1764cbe998f8d93e505a20e4f664e61 ab0341c704f782a429c1fd3e8af15a62b4b8cdcb071cf1ea42a866b411502c81 +lib/codeql/xpp/elements/ModelElementUsingEntry.qll 2e436a7f6cbf1caed029d334b23291ec437aa479df44489cf5dde5fec10bf73e c6144a18efad63433c67c335a4757c5430cc0ddfc236539ac54e9b242d14e4f1 +lib/codeql/xpp/elements/Modifier.qll ce81c10af9f4348ff277bc51027f599e2f10116967efa1ff141be8707ccb5c08 bc2dfa432b4eb997ce8a6b94dc7e323b5c63522788aaaccde3113a5f1ccafbee +lib/codeql/xpp/elements/MoveCursorStatement.qll f79841eac15da37e9f06219f36a24966ff90efccf03bd4672cec247be0e49f61 2175935e171a381b7b2d106d84dc0452cccd05a93a44215702d20a97185f1775 +lib/codeql/xpp/elements/MultiplyExpression.qll bc467d7e336743d1416aea48472dedbe86d1041f6c91c19fac688bdd82d7f319 8172a0f0c39ee5ef3380405e08833b21e0e80884b08b8646931f78e60a0b2928 +lib/codeql/xpp/elements/NamedFieldReference.qll 1cc44c81c70442378937bb3054caaa8da0d37f7f70972c9d6dd3a0c3323439a6 b0f80fba4c4607998a3d9de30f8a613a519ff8437245a5466cdb63e6e3eeab1e +lib/codeql/xpp/elements/NamedType.qll e7e609ee0c94163b6b4c58e0b010c6a9d33169209785c411de63731267966cce e2fb105ff0ddb85f62de090122b48b2a11123516c558ef1647912a052f21e7fb +lib/codeql/xpp/elements/NamedTypeInternal.qll 619f728af409d6ef6af29314595c3886f711e5d9d7c7cea389e1e2bc393ae321 1203b35fdf8b6d1870969f3b0d44a8045ad20d95d79d58e9e3cd598e08be2599 +lib/codeql/xpp/elements/NewCall.qll bb559a16824413d66f8d65b2d0466c95933ba061fed3d70ea0e22325ecc19109 09ed1752ce08c4d6dd4279de1b29d49c1a56df8be5163961b6971488bf2d2817 +lib/codeql/xpp/elements/NewClrArrayExpression.qll fdb41b7f3c7964623b669d7a13aaab7be6f2ab290aaae670bec9c748f7715a9a 86991703dbc8b3ceb625434606e2bee5622b8edb7a87b7f73dd7ef117a96ab9a +lib/codeql/xpp/elements/NewClrCall.qll 9f5f8d7650977f4ab53d66d7d742b3487000968efad6a6f35928e0d7a7469700 e959d80a361e7f5932116048d279cbb2c888eea20c06810754d9b9c48c0333d2 +lib/codeql/xpp/elements/NextExpression.qll 0f8c2f88991f9624b3519b0f19fdbc6d2dcbc6ac79af797fad1fb31d3b647699 f8be949c5054555c8376f720a53d8afc6699a9816197d23321882c024531e8ba +lib/codeql/xpp/elements/NotEqualExpression.qll 560d8e87cb311899e19c72d9d89989fd296f97730c32ef1dd6ee7eef69431ae7 ad878355a2577836a6477c6b3d6bbfa2b9b0da6d50377ccd8f4b2f5efc2dac07 +lib/codeql/xpp/elements/NotExpression.qll efff8c932a02ea0ec541321a3521814f6d99b2a60fef9525e613d97a060a9b23 759f2026783506755e109cbf70c43911db45cad2684c52377fc215e27b510842 +lib/codeql/xpp/elements/NullLiteralExpression.qll e1127964db1e733f1c0f8546517e386131c759b957f94163c3abe5ec957ae6fe a454155c08979b9861b0cab9024bdc06586b8db42af81b5e0887acb7d5aeef17 +lib/codeql/xpp/elements/NumberedFieldReference.qll 7aa0c84676ba48dfcc46df0ac6e1d07dff3835f604c16fc4f95907523bf9311d d78f5a8648139c65fd33b1c8bc93b33b36bb0a96bfc01bd7074826bfbea57617 +lib/codeql/xpp/elements/OrExpression.qll 01e1624159da99f9c116206dac9d5209f8fef6d3fa3fcd2ad6b23c5ab95610ec 382c46e2e804e09647d855b05e1c89c492186dd1ad5760de83656715303a220f +lib/codeql/xpp/elements/OrderElement.qll 70c6215b8192f05a042c5189e8a23708183c282779279088beb9a3a0e65b62ad 1d67cd96210d7e1288265838fe76ed7513ddbdc3de5088bd6db7c2c2608f4161 +lib/codeql/xpp/elements/ParameterDeclaration.qll ada62581493f561b57922b45668bcd8930ef2fba52a2ce5a830562bb5289b2d6 b6f8bf5107ead70c9006bba2293fbc781a5f81d92de293678c591d41137f593a +lib/codeql/xpp/elements/PhysicalAndExpression.qll 37ea23c66cd1fbfed7714678195215514abfba1536566f141f58158574ac4c24 8ef20b6ddfc0946f85a60143623a223a87f893a9b59ec70a5001de5d3a0509b3 +lib/codeql/xpp/elements/PhysicalNotExpression.qll 1684a3ec6c3776026a2a5e23e736dd38678bbd710fdff60214e4e58b6fbe8fbe f54e9fddb32112e61be6b942927e55c9de9c470c974135a684fe1222e1b97d34 +lib/codeql/xpp/elements/PhysicalOrExpression.qll 217ac268dcb9c9c3c171becab63fdd2dc26292b8f623dfaec5410cb271f337e0 0db5e08604ca6fad4009cbc6a8405dea272571cbec90da93226831fd4fe2a56d +lib/codeql/xpp/elements/PhysicalXorExpression.qll 1492e91be56408e8a048a21bbd0f381b9917281be292584950cd9c317cd8f33c 9412a26509a314c902e394b081316f64dc07fc63206929b1f7ce626fb77048cc +lib/codeql/xpp/elements/Placeholder.qll 4556336905dee2a8bce790ca84e71afe547d2152190666db4d9a083819e0f052 a044b9924067f6111fec4eb3dcb61c78172eee9f1f2d75ddb34a99e68f27d5be +lib/codeql/xpp/elements/PrintStatement.qll 0928b5ab55237ab6a9abe0143f3881291ada10e039919f9d51b4e126ecca71bf 29d6d7e23bd8d65e15fcac9873daa991db943bf0d927c910dcdbe443f2fa30d8 +lib/codeql/xpp/elements/ProvidedType.qll c86c57408374739866851777a6666b4e8384934a874818c2e9da4e41f2f0b1a0 3347c0f1f4cc1abf56bffeb72d1ce8c9ec30cebdacf2a6ea52de21b490e32f80 +lib/codeql/xpp/elements/ProvidedTypeStaticCall.qll 393c15d9f147277ea5a2aae63cf9aa3961a9dd3e497ea6edb0e3dc3f4afdfaaa 5f2265473c4ec0b0c940e3c041e97c697aa5dce1abaf8042f8c61461430e4739 +lib/codeql/xpp/elements/QualifiedCall.qll 651de390ae53ee76b15cbe7d995b81e45d2b4154b61ae4583f574f6f54aa340d 975580e2558af3070a102c5bc7d3ad8ba49d442d53fefcaaa5e1b87fc753c438 +lib/codeql/xpp/elements/QualifiedField.qll 6c0152a39381d7c275bcc7a40f6172d3d49f12174e4a63748acc5a7657d6197d fc16663a418214173300ae40480732f7fe5139258aaf5be89423423cda8c80fb +lib/codeql/xpp/elements/QualifiedInstanceName.qll e9b17b979f0c3e43cab10ff43334556003eda28811ee32cd2482507ba2e915db c83276b8d70923783529eeca5444d30dc67501b535d68611d323a1ac7d9ce1af +lib/codeql/xpp/elements/QualifiedNumberedField.qll 014467ab8939c458da07286a6c33068990758e5e22905acd6225acf9548a0693 10308000bb620a433de02849dec9cde17fc32ced09f37dc073a97afd36f6603f +lib/codeql/xpp/elements/QualifiedStaticCall.qll 932719b7bb14424bed98712ab062147e5d58e6cc469ea6ac3888e39fc3b49cf9 b3213b2b1d23fcba9dc2abb6d4f55e0a0171c3b188d45084d33e9f5141733f10 +lib/codeql/xpp/elements/QualifiedStaticField.qll 583041ade7868a22990733364dcb089e05b8834e9b75a5e0fbfc91ab92bf5fd0 d3a1b9a1f54c7e248e657124601f5fd9dcd2d1326c185f500d121f7184008e68 +lib/codeql/xpp/elements/QualifiedStaticFieldExpression.qll c32cd3b876c1a0f8cd4c8e17cfd2ad3f41467c8931ea1b84eaed6ae9ceed82cf 8b9e04ffb1ec844e17b3a80a4b239fe3bc1f4bcef47469fc754be534b8197df4 +lib/codeql/xpp/elements/Qualifier.qll 2c8508ffd498657a3a4431fe4f2f48cc70522513c8286b04d475f00de635f18d 230d42248714fb4f107fda61575388e21ecccc572fd4a0897b3a1ccfe4f3252b +lib/codeql/xpp/elements/Query.qll 0d9b27a4c7d535843c2fcf50923654d8bf33a8ea1e5f3d014d6f7447f6d0ba16 4a99dae2cb688f802eed00e1b80e39af6f39399a2a250f8ff35359fabbe3ac48 +lib/codeql/xpp/elements/QueryDataSource.qll 08b73acf7e9ef4490ae096a572344d333f7ea40c176ec3f1a5ca7e0cf6319b8e dcb3d445f8a7d270c9c434b1156ffcb7b9aded0f612e413b4706bc1f41294c21 +lib/codeql/xpp/elements/QueryDataSourceHaving.qll c6c14f320a5fcae024b54d90fcc21411ef03572b9f6a7474372378059bab5e88 d8b20912ce601b6f9bc165494b0ec672dc80553e6edc4e0e150dd09ce288e7f0 +lib/codeql/xpp/elements/QueryDataSourceRange.qll 1b6d00e8b281ad764fcbf1fd79eed13d2079deb2e0ba7ee0c1fcd3d7cd5707bd 4a66c662e28125292f46ddaf767ea615fb3c4571c7c49b918c04aae02480ed11 +lib/codeql/xpp/elements/QueryDataSourceRelation.qll 26cf7a2f5bbc6372d938c0eeacc2820bf0157c0ae1f21eb245e8e35f0a07484f faf5d922e08df6684299a7bf75b3590f75f4e578621e43343f6b90c11e3480fb +lib/codeql/xpp/elements/QueryModelElement.qll 9a37260208fe148878e69e9d9d2a829f8aac799d61944344ade761fa644ea83c 9b5a1b5fc9e40feb9333ebd16441088b7b4fadff4fa961c969221314e238372a +lib/codeql/xpp/elements/RealLiteralExpression.qll 60cc42056c93dcb0cd7d6cfbb2741591830b9b9ec19466a7cb36697e323a91ef 2a41d82c76f2f50850d9a9388b9a7fccbac61923596ec9860e121edd046ff0cd +lib/codeql/xpp/elements/RelationalExpression.qll 87175f6227ce6045d18adefa0933d909fe5a99ef80c6a45a0f93ac80ad8759f4 9c26e8f83cd1382b6b62e1043d621d0599bf375025c20e9db806e79086b346bd +lib/codeql/xpp/elements/RetryStatement.qll fbfaae1c4b3ae3f884c720e6f2602c61603936e72bb9b8c15295f7cb73c44eb6 ada2e9af555419108f4256c6e914744678b053ac0426e0a44107dc983bf13ec7 +lib/codeql/xpp/elements/ReturnStatement.qll 3a531335d482e74219059dad4ad362b4ad19e08a3a014f32a1aba17889ffe525 7c3e8f22270657b1757d43313eb359d16de1258667636a3ada96dd1367f42861 +lib/codeql/xpp/elements/SearchStatement.qll 50352606d1361847976b916ddebc1aef68c6e7693685c738227d1c00ffeb1ff7 abef16bf28543d0c8f9119d07bdab086c2ac8d91b8134516a3ce56d3edcbbce3 +lib/codeql/xpp/elements/Selection.qll aed1c1a4b5bf326f0e70c916f8079181e4039f7948a075fca043a4ff2c64ba0d c9ae9609b49fde691f687b01f627a53fe24ab2ac56b134f444fdf8570dc9bf9a +lib/codeql/xpp/elements/SelectionField.qll c8cd9510834cb52d9cc81b556638962a72107183b44f5fe60cdd9ac0900ffdcf 5147160e5e839626ecea2eebaa599b00a77a9d8aa8bfca502d99364dd8899b6c +lib/codeql/xpp/elements/ShiftLeftExpression.qll b8da17f2be085fec7f105caf986bb9242886742335045b2022c6c23d59ef16da 947df11b3a8ee41f5d6f1004bcb63ded1785d1152ac49d566b7c00e15622b3b9 +lib/codeql/xpp/elements/ShiftRightExpression.qll bce119c5d986ea87b5a91e626dfe20f5576b331d8f5892beb2937731c28359c2 19547e3f63cf51b2cca3242b7877044514f48b48dbdcc79631289495052ac6c6 +lib/codeql/xpp/elements/SimpleField.qll 7c2ba9c0a8e15bff61baa10115727a1ec0216d68ecf43c1fcc15398ba225414c 1b035a882f4eeaa3061e76e52fcee3e706f2ae42d0ff3679f63df46945d8eca7 +lib/codeql/xpp/elements/SimpleInstanceName.qll 80682cba090bfeab1103e2f328e5ff59bdbceaf24880701ad03c7b6233707a39 b20e5da0809fc8d6023cc8cc2fe651c7309beec1d1829e6b21d091ce233b1b32 +lib/codeql/xpp/elements/SimpleOrderElement.qll cd4154741691dae3bb52d09ac216c1b7c6500a84970209d3e98f2cb12797121a 6dcea64a00308250ac3ea82a9211d01e1c2fb4f6bbad0d66d16521378f658136 +lib/codeql/xpp/elements/SimpleQualifier.qll a6f00a25d504f44a9d3682b6a59077e0a442ac96dfd99580bdb0046695e6c5a0 c1207bbc5c296a0fe19ce87556f9a74976c1c64c94820d8c58b0ed8eb454eaf9 +lib/codeql/xpp/elements/SimpleQualifierInternal.qll 4bfc62450068022bb9a2ccb1619080d5395748699fb7c3288282f15d3df4172f 8d8abf6bc64095fb0b2640d8265758e7f9b48c4f928c806d3f7fe57767ecdb15 +lib/codeql/xpp/elements/Statement.qll 3fb242baade0c197c54bb3c543c160258e0ca49c69cccaa8b768e45fcbc4b1f5 a5482c995868edfce41bafaf65423ecd8e8f8e8fa30f6cf386d5de6287aa3ce7 +lib/codeql/xpp/elements/StaticField.qll 4d89908c2f5210a80100f2fa14f37ed5052e687794544d5c9202e0bc6c3b1892 6415b05d6b0353760b5ad1dd2c183d2f5299b3281a834dec3e6b77e8b2e64356 +lib/codeql/xpp/elements/StaticMethodCall.qll 003b2717553685bab765999a315f41f99b64465ceba22aeaab75976f1c7bd904 945c6d7e7c39e51e30e4cfae96f5fcb26fc353287dfc10dc59622b3fb4002502 +lib/codeql/xpp/elements/StaticQualifier.qll 3cc96b983fac3915608e8eae440adeea8572b76529376908cfa0953ce80be9dd f32e36a8b04be387422d9ce6bc8bae5bd588e39113532b9fcc10ecf6aa585e99 +lib/codeql/xpp/elements/StringAttributeLiteral.qll a8ada457b678d2b8e82fc9bcb6179a55f88a9d0aac68bcfd7e12b7c46a731f7f 9fdf30a0142a43f5c4aa8563f5187097a1c505e616a85825e1375782c4274283 +lib/codeql/xpp/elements/StringLengthType.qll ec45d95d82993d786e804a0a622fcd6b89da0f05d4de2c90377ea6de455270c1 622cfb8f835e221dbced0875083c4e3a9a56a365ec342755eefd4b92dec23e97 +lib/codeql/xpp/elements/StringLiteralExpression.qll edbd98d6c0e1388852aee981aac2d0f5c849c2b4b11c6469aa6ced07c20c6e15 d687812c9f8c491b8107c533d5e6fda513cf31fbfbeb8b58bc4a49c99b0eaf73 +lib/codeql/xpp/elements/StringType.qll 3528f13351a314c8f63baa385ac7305ca90212b786ff993d63d6f9792b601771 d992b4282cb5ff612ef738c70c177d2b382c41d8c27c9c6cb34ab9124246629e +lib/codeql/xpp/elements/StringTypeInternal.qll 8a235893d2a69378ad869b42d302bc5ef96b5c9597d4b086cc1289bcc1c50262 652414cc9cdb6680a8eca7488da31c9519a55989278e8d7d1f635591129d8b33 +lib/codeql/xpp/elements/SubtractExpression.qll f9a47a8087ba3c8644b590f7081b19c608677e31adba820b94894ab3f4b0c3cd 6f8eee0c40018c2925b53102b6a5b6b27eb0777467640c8316dc535de30cea93 +lib/codeql/xpp/elements/SumAggregateSelection.qll 46b37611aa7ad59e013a6e9d2b6da3047ad2ece8fdf9da8963ec05ad87888b3a f292ada68f9a533937ff4bbcbf500e9df8f0f72893f606521c67e3c40c8bea4b +lib/codeql/xpp/elements/SuperCall.qll 5990c3a98933fe2221e6f621f7f11791a31d11ee1ffbc7dce3fa0a146999cac4 42ad5b46dddd19d1382d1ae3e86e1517eb1731911079996c424ddd669e4a31b2 +lib/codeql/xpp/elements/SwitchCase.qll a201d08a817190e2188205c145ef8f39b5f41bd672695c514868255a0a462053 62299f5ea445689edfd5285dc889a841f00a139571b89347f287f45c59378dca +lib/codeql/xpp/elements/SwitchStatement.qll 48ded2f2d80f84bd870522fc0b6216678fc7d583a62fee087b94005534880293 ab46d7d1fe7ff4a322594ee8982fac1769fa640fa8d45b2a64e7ffc70f9283bd +lib/codeql/xpp/elements/SwitchStatementCaseEntry.qll 3ae5a627c8af77fb7da8a5fcfa2676c0c73b7d54edf1737d38e6dfc9f2aa2349 aeb754cb8f0c042d98fb389060d8c904641cc31b8eb6954fe9f0c95666737f1f +lib/codeql/xpp/elements/Table.qll c458c02efd4a2d14ee7eff9301e39cc9ff4a00b461214be6bbaf6d548666c8f5 613ed1fb017283958d217b56cb866d412fa8f54fd58d146dd4e2f90de01a8e0a +lib/codeql/xpp/elements/TableFieldDeclaration.qll 9ecf44e27d6a9c9ded54b6c011e3dfe2569a203b2285fedcd7e1f5a08727b2cf 1fa3a6f2dc2087637420cfcb7ec4b0967c5ddbba9f9cfa2b1aed296c3e5c0b7d +lib/codeql/xpp/elements/TableFieldReference.qll bff8e4f72d723c1db1345908cafcd5a539af822cb2147bb74a411bee3bfb3a81 bb851b0ab5851d01767aacb0cb3b6ae22d42010f74e11a22226e7be5d969ba98 +lib/codeql/xpp/elements/TableLookupExpression.qll 38989d4c977fa7d461ddefbe97ffbe28ab4874c9dfd3238faee5b07286bfe1a5 b63f9d33eb65c3d752233ae099a21bce4bc14c047abcc9366708d8545688ceb0 +lib/codeql/xpp/elements/ThrowStatement.qll e3d1072beb5ee8616a05118d3a0dc62c4fcd084f092afb0fdec2cce614cc6324 805fba852fe62f71112222632de516523576aec9c0a82bc937464fc9132faefb +lib/codeql/xpp/elements/TryStatement.qll 6fe7cdbd3cf239303c677fef6a521cef6e8ff54c6b0d92b9ac099a35e99a79d2 db70e8e82d6cde90b11241cf212e9e5be77d224a48178ec6ccb81696f765c4b7 +lib/codeql/xpp/elements/TryStatementCatchEntry.qll c7ed06d9b643272c1a0c58b39b541755ef9615b0196ab1f2c0245e98d71e3ba1 b9163e1ed3169e3cc8bd35b7977e9337b5d2e1ceb9e44fcd322028f1e4cc737a +lib/codeql/xpp/elements/TtsAbortStatement.qll 491aa4f5a383750474bf1440ab51dc59daea68e3c69b2d965522558fa44d721e 5e36cfde74c6723485b507c96078a7bee4d504cfcd96267d185da0af2fcf2c00 +lib/codeql/xpp/elements/TtsBeginStatement.qll 015e7e3081d372e252d350e71ca204f68cf3cad9f45f1f00807911f9f307d351 24164a9ee24f815ff633676435a5208e512fad405a99db0cff33170402eae2e6 +lib/codeql/xpp/elements/TtsEndStatement.qll 226544266aa86e3b20cf65e5d4e1c04c60f162cf4c216b8873f863d4e6db2edc b63ab1aa49680f4181a314d3289009a290e31ea2cc8a9ff1be3cc48327b2d5f2 +lib/codeql/xpp/elements/TtsStatement.qll c3fef18b56ae4ffeac6a160889124b53045beeb5ed7e591c8cdf4e5df50f8512 601e1b875e489f914d2fee45a79072f8b0488361f385f4db80aa88c025efb1ce +lib/codeql/xpp/elements/UnaryExpression.qll a63e6d1b402489be694ce3406957091656d41eecca91ebcd7901975c9c643f8c 39f3b2050a1f3a29c66858d0c626838b5797f1d0e43db7c2672f14e561c1b175 +lib/codeql/xpp/elements/UnaryMinusExpression.qll 0782706876a91278bc9759e09a8a9baa5d5de402ff30547059e7487c36562d4a f4d79ed1cfa05d4b3a7a4cbdf6114519593fc486a5a16af1d64107a6aeaaed12 +lib/codeql/xpp/elements/UncheckedStatement.qll e4844f6efcd08d446e939b3b7f4430a60124fd73f974435477d526a88b769812 42041dfe7eadb4b05509182596bcfa2aae5bd8d2ff0517ec53727fa10d3eb9df +lib/codeql/xpp/elements/UnspecifiedElement.qll 6a77922639237ee0cf7bca50392e63d5c7ea7db46a90997c39b4cd26333a9b95 8ff27376c28006b32550914559ae8c72f58677c1f1bf896ba6ba464385071db1 +lib/codeql/xpp/elements/UpdateStatement.qll 705d3583bf413cf80e1d870e27cad83d267fdaade4deadc780360d5f39970c73 2d7c5b297ff6f2e7ba4fd160cf6ddf76015af579cc63943e254f9e4996911b70 +lib/codeql/xpp/elements/UsingStatement.qll 47c7fbb835b4019b0e541a2ccf821012dfdc52bfc0ec3c7a6156226572c86fd8 6d88b20fa45189d38ab986f58f945ed046ca4ab0c98decab0b03a043b1c00445 +lib/codeql/xpp/elements/ValidTimeState.qll 93e4a50fa3389374c504be93209fea8386a5f53da93369b92a74370062f606b9 1c9724de54f54cbc6c9e27dd14d029c9a8ed4973c0fa2d873acaad15c72195cc +lib/codeql/xpp/elements/ValidTimeStateDate.qll 41676af6a0a9697b1383463602f9c3b290b7d602b41a44aadfc1019e622a6e03 b06674e41cfc61f02b2755ade3ecb03d6646a8a3d5ca7ce4a117426e0910077c +lib/codeql/xpp/elements/ValidTimeStateRange.qll 715b29ce1dadafec41882ed34eb630a99879e99b692e25443ad7268e1942d5b0 9884e5e6eb2f364f5e13a01d3b4ba63d91cd9ea4958566831eb308fc28a28bd1 +lib/codeql/xpp/elements/VarType.qll b6ffc1acf19129016559b083a212eb8683f90500d4a0b61a2be24cc73dc8dd39 294ee1509f535707ce0ff226db41f4170456609e1151e4f2cebfdef0a53cfe4f +lib/codeql/xpp/elements/VariableDeclaration.qll 0264cd7987d1568ff28a3c3369b6f0882f3a237a215c29dca691839ef14ab42c 80bb3a4249b6202546a22a4a0fd45690325c54098ae0887cc052f24056ca76d2 +lib/codeql/xpp/elements/VariableDeclarationInternal.qll 21a9be52d17b47f231e888a2109b6650bd309616574ced7b391308c7ac85be82 0f49b729a7a3dc5e005d05f6ddea4c2a5a272681ad212651b42a8f5eb4f69544 +lib/codeql/xpp/elements/VoidType.qll e25a1fea11fa86f9ea5c4644c798ef25593d84189ca43234a316d38bc19a9e3b a7fa5e0d284cee12673882b386a7b254bee1081276965387f9121ab5e3a1a7ce +lib/codeql/xpp/elements/WhileStatement.qll 8b4b8925ba630ed17f5ba7ae31351c5a273acf6f6dee2453e73e4ecb8d15f731 c5de0c2445002111dba6655a81886a4f5ed3e62e62a72b27208c25c04f77f232 +lib/codeql/xpp/elements/XppTuple.qll 3b3cbc9d2d5ab228bd8e5afc893a852bde042009509ac0aed280299269c96ead 56cde522c3a823c019c2597471026a7cfec09f7140d5f538f288c3607f856e3f +lib/codeql/xpp/elements/XppType.qll 6d07f54d6fbfe27bc543e041a8dba01918be289d8d961d64d0cd799ee2779977 14358c9d1fa80f955b50ee4410885c8894e7434bba9fa10756900649f9bec3b6 +lib/codeql/xpp/elements/XppTypeCompilationUnit.qll 96d628eeba778bd64a9fa365be23406e237ae0079eb88126c2585c362938f4e0 2bb8b9a472127cd6592125bc429766847c15a8bad5a2abd922cdb21908f85403 +lib/codeql/xpp/elements/internal/AddExpressionConstructor.qll b50e97deb68dcc9843b45f20a97db6f228690120d56be24262dbdcd670fcdd77 1c450ae23725158b05b30b001bd406c628548ca236879938dfde74f6bfe934a0 +lib/codeql/xpp/elements/internal/AddExpressionImpl.qll cb41608db7883064ed17f4d6395911622a81611712f60770761ed012ddd178f9 6804d5dcedc6f754b319073658df0516eb34ca89f7b8b94a72dd1f4d82e48b53 +lib/codeql/xpp/elements/internal/AggregateSelectionImpl.qll 591121fd40b21ccabbfcbf736d17c4ba91ab1090904e17f96846b2d017da503b 27c657568903ca8209a2af96d6f5d36d80c06fe2b9ca7c54d309b71cdd3f80e4 +lib/codeql/xpp/elements/internal/AllFieldsSelectionConstructor.qll 98778cfdecbe94d3bfd473719046c22ae82095341ac389d5901450b8d08f997e 45949ca415f132316cfe83e82ba0997ec62c379cf8aded6f1140c69e4da74ee9 +lib/codeql/xpp/elements/internal/AllFieldsSelectionImpl.qll 929b4c24f7d03e4544c8224c2be794776a49be0e202c6d8a20adb752ec8cf944 8aa381165cd068e5d3574c5dea50e11dd248e59afac4e96edd1f34ee46493945 +lib/codeql/xpp/elements/internal/AndExpressionConstructor.qll f8dc211d2ef8f3b9002b38ba4028fdf2b494c5dc949bc65bb54bd9cd350aea79 51e39b5e73110ee1642c235dab0ea50655b796a53c1584eb6cb4e0dd74dd6124 +lib/codeql/xpp/elements/internal/AndExpressionImpl.qll 3878a82098b992e84e2c49edea6a5de420472f91820468071ef678b2b4f9e735 def3587b1928570ffb2d83a66346c5b51cdd486a9d327de0425e7409bbfff7d8 +lib/codeql/xpp/elements/internal/AnyTypeConstructor.qll 815be9f100d1c423d6cf34abf8d66c27c3a06cbac31a590f47682aed470976f4 06372a4162052ee8b922dd272bf2d06c89815eee5e27e3d67aa77d3859050835 +lib/codeql/xpp/elements/internal/AnyTypeImpl.qll 32c0250e90429ea04a99f46c22b2ce53bb167c00f3b1f4b7916d0d8f1b21d639 a39b4feefbdc5c1e6afda4094ec111350dded7af56930ce3a7028a36c6d1335c +lib/codeql/xpp/elements/internal/ArraySpecificationConstructor.qll d2cbd17f6468e82936e62ac958f593797dcf9932f554006aefeb676e82a19d53 af72b76d49156d51769e3b533c9329659d73dfda4d113cdeb7c225c76b6cd734 +lib/codeql/xpp/elements/internal/ArraySpecificationImpl.qll a5dbdb818278f0fd31b5d37d00b2c615550dc4e2ae177b7f8ea129d9b995ae92 53c1dc73bc7c39b89a2784ceadfd950211aabc0452375be1e0bd8fd125e394b0 +lib/codeql/xpp/elements/internal/AsClrExpressionConstructor.qll 0462f058d6e142e9b913ec798afc45b1aed980693405f981f3cd74086f5f59ca 50f51d4126cc30cea616b80aa40a504ba34f56658d5931d62886f40c66159f82 +lib/codeql/xpp/elements/internal/AsClrExpressionImpl.qll 4aa424dc210a73fae6f585856b3b7782acf53f33294e79224f3919885ccd3dff 8ba6b98931da840f24b37566e617c0d7261f7ff98d1f211d23bea68df848f9a0 +lib/codeql/xpp/elements/internal/AsExpressionConstructor.qll c3473349b4092ec2518ea0a38ca1abaaeafe4c6a3851191182be2c54ca5cd7df 52bb9d36e994dc048352712fdba7009e550d7aee6898df6a77b17c89be38892e +lib/codeql/xpp/elements/internal/AsExpressionImpl.qll 8c0e25976b8e52b48183cb32b9febed2c009d63cb6e94f754575a98a5e732dc9 04af685f57aa8e09a002e87f5e02ddb3f93e7b9bc18083afe7dbc142d0474316 +lib/codeql/xpp/elements/internal/AssignDecrementStatementConstructor.qll b7f15840bbb13442eb0ab31e5286598e911f17d49e62d504e145dd2b2e7c4dfb 35bd0684582a830c2aad4224a0b4a2ff26cf458f30d2c00b0be22f034323e1cf +lib/codeql/xpp/elements/internal/AssignDecrementStatementImpl.qll 10181a307af2f97c53a852b3de59a650cccb33e282b81b77822bbdf78e75dc56 ffe4515ecd275b60e74f5b00bcabf9add4f9e93bf1dd42dc2ccdfd7d647d1eb0 +lib/codeql/xpp/elements/internal/AssignDivideStatementConstructor.qll fa24943975bf3af329f1a9c4459f3b6afcca3cb8039aa09db009b2102aa3edc7 2b5a5cb0bf52d404b0d4f54689e0d19778d93d90f80e747686941ee471264b74 +lib/codeql/xpp/elements/internal/AssignDivideStatementImpl.qll ef0c2387b1f16f0f25d92f012335c828634e3f2fbf44b0018e0265fc92b0d84e 549203ef6bc64ed8269d299bc180710dfb2007d9517263deb0f17b7570c042f4 +lib/codeql/xpp/elements/internal/AssignEqualStatementConstructor.qll 95a9f52ef1942f55bd4eb63f1c42fde58ddc8706acd17c55d51cc182b19b8434 13e4b00dc4574a47b7c2fc18e36c3ae16c788debd61dede30d689fcb18488f03 +lib/codeql/xpp/elements/internal/AssignEqualStatementImpl.qll d296c45f6c3479fe108f0e761627be8e1f3f678d9135f3ff4eaca687db41af43 00dd8e976c26973bae3cfc64c436a72cbe01b8e796360001e5c8eb55e8a8ddd0 +lib/codeql/xpp/elements/internal/AssignIncrementStatementConstructor.qll 80016c8c66a87487c32a74d5711f6e5d6400619b7bf6f9ef56879be0c05e581b dc541772600cd08d168b469d079c17baf65ce9483bb03f97187f20422f8df2b5 +lib/codeql/xpp/elements/internal/AssignIncrementStatementImpl.qll 61da0da8b909fb8c345b8b4c3b0925714b60778f763698056dc9b026e78c0e9e 39e76c6888372b35e6d74d1bda9e8db8e41def75c756d90fd5f31849f1afaf7b +lib/codeql/xpp/elements/internal/AssignMultipleFieldStatementConstructor.qll bd34c73904e1b078a4d0e4a6048c48b1a6b8d7b2c13ba710b0d571a1d90872b3 e031c246e9501f7224661631e2f50491b9fed5cf7d0450a6f1ed723aa8bb5422 +lib/codeql/xpp/elements/internal/AssignMultipleFieldStatementImpl.qll 5020d97b1535f37f43f709201b607f184e4add2467592ff7bd1fffbd8fb417e8 f6d3b77f03cd8a255eec411835468e4645f0a6d5e8e803d8f14f861289559e2e +lib/codeql/xpp/elements/internal/AssignMultiplyStatementConstructor.qll f34c3ffb0e2cb520b73d587186c8c6242ab49df150a12bd2200b47a374f5ac79 40b0385c09fd82c1f2f142544dcc63b4835521013817a79591fd9cf7aeb6b7c6 +lib/codeql/xpp/elements/internal/AssignMultiplyStatementImpl.qll c19f2b9c69aa040be709cff8a8dec65c32a0652d4b64885c16cd1eb63e58d535 6607ad769fcce9c03a5cb20220d4f79d3c8c70e3d3e8b0a3b64a96aabc4ae671 +lib/codeql/xpp/elements/internal/AssignPostDecrementStatementConstructor.qll ccda5d218f3dc496d7cbb4a567f977924486c6dadab3c7bd430e2100760717bd 30e1d88d21a68f4202c95a9f5e9b6e80bbf86042fc62bc49641b9ed876c1707b +lib/codeql/xpp/elements/internal/AssignPostDecrementStatementImpl.qll b40a8e9fbe22fdecd6ce2497c4924738a28b2956ddb77fda60948fc84c79ca9a 251aa843869c4b0e629d5ee5012d59265407bfbfade2aeda4e07a072e20d9242 +lib/codeql/xpp/elements/internal/AssignPostIncrementStatementConstructor.qll 5ba66a6b685513e7ca040c79e9e8e4c606df9ddec9a5f20e5170efd4ce6bbe3a e9b008f5cbe02aaa82b9f2900eb58f76d8522a74479f88e69a99624389b4a7d7 +lib/codeql/xpp/elements/internal/AssignPostIncrementStatementImpl.qll 9c041ecc06f63d574aec145bf159e81c6abea8717c73737dfdb16ad63c57de5f 8a03c4db0aaa45915e86c6cf7701be9ff988c0163909ad6e468171d23a10bd29 +lib/codeql/xpp/elements/internal/AssignPreDecrementStatementConstructor.qll 5ca8ed6550fa1915898f524f77e84be95d55d8ad246bbccec46fe4df00971620 78eccc19c068feb31284b002640128dbe5627153e40f7107344cdc4cff888d7e +lib/codeql/xpp/elements/internal/AssignPreDecrementStatementImpl.qll e89b13572779af0f35c837ada709718d4e51c839da5cb7077d65eed50f9a3ed2 0b3c7397bd67ba5029052207cf44f0ff8b3d1a8cbc2e858fac9e81692dd86548 +lib/codeql/xpp/elements/internal/AssignPreIncrementStatementConstructor.qll ab050249d16ef35557991eb2e3486bb341ced1718c65a9e25c2cea8b1324d974 6f256db7d0eeee3f443a0463bbf4318acfb6ddb9144b58e95ceed80d68079796 +lib/codeql/xpp/elements/internal/AssignPreIncrementStatementImpl.qll 536834c6b88cb02fd4d4fea5129b94282d31a4fe53826ae87ad26eab097389ba 8210c0b45fe654afb192372e607e6ba6b6a24099538148a3f4ed2accc668fddb +lib/codeql/xpp/elements/internal/AssignmentBinaryImpl.qll dfd2342cd739faa42b7490324e74399772e897205ad48051b7e5582257031a49 2029bedcdb31d6cd641e05d597342ce65c6d242f0695bed2c6ce617b2a75a859 +lib/codeql/xpp/elements/internal/AssignmentEventHandlerBaseImpl.qll 3e7542b8dad36e3c6bc32f3297ea1a3842769d44c770e81f643e51b20c7c1bd5 d2d7cedef3416d653a18dc4e32cd8dd8e90dc3c99a064ae38d20470ad072b043 +lib/codeql/xpp/elements/internal/AssignmentEventHandlerClrConstructor.qll 999849ebad452389be71e2b8c240420a052768a5311c3b997355e870292652e1 26e4b79761f3b7f438600a041b9e22c75fc127e6d7669277f38a06c39d7cb887 +lib/codeql/xpp/elements/internal/AssignmentEventHandlerClrImpl.qll 1eb495f7f8344cdb65ba7bfa71552f7c42bed7302d40b68fac558ad3461cd7ac 98a362787ffdb827967c9b69d188bd8ce69f24cf2311f200236aa51ccf3db9c0 +lib/codeql/xpp/elements/internal/AssignmentEventHandlerInstanceConstructor.qll df122de64c6d97db49a31f02ff1afb4894a1e93089fe45a838fa7843ea1f35a4 32db3d982bd7824fa9a536df768f4774222bcc1a7bfc56cf23914586efeb249e +lib/codeql/xpp/elements/internal/AssignmentEventHandlerInstanceImpl.qll 174effcf2057f95fb8298b82e22cac7b16e5de4ae7c3bc794a8bdd871f0ab781 4511f9144646d93be3ec82b0e601b6ef3c74f0772a95456ad2b4840a8a1b8484 +lib/codeql/xpp/elements/internal/AssignmentEventHandlerStaticImpl.qll da0711ce6c7a8b8715f4cb67e87b9989b5045c0f6a603f73d7b5aec55a7632f1 306e349e4a8fc6374e2c67bc2fb9b7c1837f774c0e9aa5cf3788204f915fec81 +lib/codeql/xpp/elements/internal/AssignmentEventHandlerStaticInternalConstructor.qll 7bb50531c6a97fe49dc1a2160063233e4adda983c5876743b4bbc7e446d48a72 4626128e47a0fb59cae1a509a5e5c86daf6c1b96072d24d39c62795b14d51888 +lib/codeql/xpp/elements/internal/AssignmentEventHandlerStaticInternalImpl.qll b7dee92f4e904da92251cbed0298d6ceecc68450f411609dbdaf3277bc0aad0b cf2b3c76d315b9ac88f13dc4ab70312b0166880f2900d2845c05177e782198b4 +lib/codeql/xpp/elements/internal/AssignmentSingleFieldImpl.qll 50dc79bb5a149d2936c1b699ac677e97863c6ccf3d0a60153468cd3d1f8819db 9d63f0b0666beb58c6716e178ea77690f944767ed973ec72426b3f84982fc1e2 +lib/codeql/xpp/elements/internal/AssignmentStatementImpl.qll a4e05da120e89fd3d0e76aeac2a4b5188f40afa1196fb8733b761fca3fe85be3 be1b8856d399079cc4137342cc64ea59765d59da36c8dce55471e34af872d682 +lib/codeql/xpp/elements/internal/AstImpl.qll d9e9512358dc580b8aae2dca65fe56cad3ef2077ab7134aeba03e160750bcaa6 5df9b27f41ff71752ab60a47b04629ba0faded3611b98435a8cbc5a3c15fdb07 +lib/codeql/xpp/elements/internal/AttributeConstructor.qll cfd117757e55da4e66b74c4b16eab2c38cfa7fa5627117723d212e9c284167a4 7d23f43e569f6464aaa554b0a3559104994184caacb7667c278a0ecb2012f4b4 +lib/codeql/xpp/elements/internal/AttributeExpressionConstructor.qll 8a06ccba6bbc05f63f8ddbb82754d3db9dedfc762c9743e517f123ed09396191 8169cb5cc20005740c40d377d1d64b6c62e5d81eafb54f5f43a9843b7f226982 +lib/codeql/xpp/elements/internal/AttributeExpressionImpl.qll 97f63f14e88ae588c96e454b8fa95d35f947583abd853f886bf932ff59947759 e8b33a00b154f9da01941e2a97672135f928e36431aa1d56da831bec39a76093 +lib/codeql/xpp/elements/internal/AttributeImpl.qll d9d412cac10457d744a7b2e64130823ac5167e325284132829e0777f601664fb 080fc3a1771e00d433a267a9c370ae79ebfe2feee421ad133ccdf7ab92450a69 +lib/codeql/xpp/elements/internal/AttributeListConstructor.qll 0d1805619dd0f54ae598cff0c298c8f01ce13bfcbfdbada618d0ee9314ec8d91 5cfd87c0b94beae8a9ff4f5adb192e3424fa28819d71758113962983caf02547 +lib/codeql/xpp/elements/internal/AttributeListImpl.qll 09a7e8a9abf6c5670ebc692ac79291eaf024660212a48a6cb5666e76a9565d3c 867f60b04af77c78cc904719e1e49ff8b50d735d30d5d8324d75e4a54aee06c5 +lib/codeql/xpp/elements/internal/AttributeLiteralImpl.qll cb88a8f01b4300078aa72771ecc6ea6047d64b219d9d9e59adc65dd21f9c959d fcd6b68db63c713e6c045ae4d46158fd365d4f1d93e4944ed7ef3ff623bcaf76 +lib/codeql/xpp/elements/internal/AttributeNamedParameterEntryConstructor.qll 73047a51879e8f94045cc4c850285d931cbbf3f5e4c2d47be7816bbdfa141cd0 11c372bd7c847e18eddef3209a983b589bcca4aae94b2d2ee75c38b943b62b99 +lib/codeql/xpp/elements/internal/AttributeNamedParameterEntryImpl.qll 1ddef590875e672a5aee87081dd628cd879d3de7043d03340b2ad77804cedc4b 3d61bf2ffc9f94efd3190d937e02fbf2d28f9a4b6d58917c8fb7e7b6123c203e +lib/codeql/xpp/elements/internal/AvgAggregateSelectionConstructor.qll ea589edf8e3ca796f85921d10f41cbc34b4f9ce2e942320122df5d609e62aa53 0dac64810d55bad7ffcb9465246bd21e9098e407f5720b411c8c5bada9cde599 +lib/codeql/xpp/elements/internal/AvgAggregateSelectionImpl.qll c8881a3bdeff3b4497109afe95b1ce30c806782fa9ca5aad915f2cafa8e58c38 4c216c74257abbeba663a3e7d27f4c0762ac33411768f7eee5dae41c83eea4ed +lib/codeql/xpp/elements/internal/BinaryExpressionImpl.qll 9e200be5d6fe86bb2164ddc8924d35f54404b439176c2cb41cc756a73f45df1c 60a91e14f6e88b5c93c9a38970d280aa627ea41a2ac05d1e8404e1afb776ba91 +lib/codeql/xpp/elements/internal/BooleanAttributeLiteralConstructor.qll 858518fe6abaccb173dab23cbe41f4c47e1ebb588318d57b9c920373ae8c0ba3 f1d56ee58b051ece914bb4acc7b9175b543b922ee0f98278a14dc0e7d3d2a5ab +lib/codeql/xpp/elements/internal/BooleanAttributeLiteralImpl.qll 3a4bf1bbb775d42f4d607c927d5e450b1191cde8c521f08ee4d88c3860771830 0319781d0d58f4d611e95591c99cce08697fe7b2695c230483989631fc03a569 +lib/codeql/xpp/elements/internal/BooleanLiteralExpressionConstructor.qll 7f8cbc363a6f7ccc4de82ff1ced7e53cd15a9ee6b2b48fd263bf8bcc6ac3d4eb fde85a83ad908b53adeb426eaa64847eeca63cf137701e7b0c9d9a9b3e3224c9 +lib/codeql/xpp/elements/internal/BooleanLiteralExpressionImpl.qll c6c1df4cdc9364afc5c6a80512d90cbdca6687a51b049b160c5417683866b27e f5dd14a4de9e549d508e11d841bb3794c22f282d32bb1d8f202bc0968e10546a +lib/codeql/xpp/elements/internal/BooleanTypeConstructor.qll 604cf4722513f6d93d71192e491c8086a030be7d5e647ad8b1aec60636633c1c 8ddfc3353d3615add0f49ea6d1ec32a10d290b161e1c9996a405da7aacb30882 +lib/codeql/xpp/elements/internal/BooleanTypeImpl.qll e83a3bcace9f057cbe5ae6674da9107b80d0fe717e97cf47f4971a1f05aaecda 16206bf6f6535fd7ce49ce346d41297f0d17438ac633e775e235d472a851a3f6 +lib/codeql/xpp/elements/internal/BreakStatementConstructor.qll 7199cdf71e58abcf3cbefadb5f64f168f2e71d12c001ac164ddb88b15640d4d9 4bb241a4c5d7ea4d79ef206acc744f663fda1c18366e86ad2739be5a9a4ebb96 +lib/codeql/xpp/elements/internal/BreakStatementImpl.qll 50766f12444ac488c56321e3c688a9e10d995880db8fee27576e0e180eb506ac d05d14507abd5d76d95fc4bcbc9b1ac57b668bd98756af721dc7b9475b00b6fc +lib/codeql/xpp/elements/internal/BreakpointStatementConstructor.qll 623ba94953dd83e8b3e89b0ee2b34a4db843e197f777ad5d5d70e1d2d7ab1e91 6a1d2d8472db84d3479f03f619ba822d0a3f41fcf987989c123f409410764aaa +lib/codeql/xpp/elements/internal/BreakpointStatementImpl.qll d4309f908515d10df1433615ccec52e598f20db70ba126757ff5c8a814109a8c effb21f8d240e3f0632a2b6929f54f5ed0adae31c2d6ba1217fe9d8d473c3728 +lib/codeql/xpp/elements/internal/CaseDefaultConstructor.qll 2235f2d206c4bb85e564ab447bda6b65efe53ba15ed91eaa11e11dd3ef7e5caa 7af9a66e95601c0feb09e0f88f7e06746414d46a0493066c8e9008afd532f7a7 +lib/codeql/xpp/elements/internal/CaseDefaultImpl.qll d460457b28b85148869c66911fa8b626de40d9f617db669fb70ae1a62b63e10c 6347445c1b5dc4310edc77eac0a9270a0165eedde20400ffa3a897017745b1a2 +lib/codeql/xpp/elements/internal/CaseImpl.qll 5e41d0121244e5506078874ddf53e9135f5efdf0689af5b49512cd3a4c0a0c9e 1c6153c82c0d913e6c1619e6f1a16a56652d1b200ac20cb278c6ba03c60dcf7f +lib/codeql/xpp/elements/internal/CaseValuesConstructor.qll 61c091a5f068e230d6957ab69359f9faa075752292b7eac27f777e16d3312341 58773388265ba516fb60fef32f1a7b88d11ad5a3006d65b6eebd245692fa8e58 +lib/codeql/xpp/elements/internal/CaseValuesImpl.qll 85d3a90eb2b5d728a9b4a086ef262dc08f0858434e8c0cf9db9317a94e307490 e567f6f39ef7c81e49355819adea967caaca6c0a9f7d4908d2da60bb68dd9214 +lib/codeql/xpp/elements/internal/CatchAllValuesConstructor.qll 2eee0793447b0469749c611645c6b52f93709f22d8fcf631a465c3662eb740a1 18860e879d5295b202e40652b88dd05d7209fc36dbd52fd4bcc57fae3c6b9b1c +lib/codeql/xpp/elements/internal/CatchAllValuesImpl.qll 14a121d6ddc4a46dddfdc5f164d839a678316912f4cb64991a9161da40608bab 37f102b828b036c91c45f4584a8c82fd9844787fe6b17cdaddafe70c63bcb8ac +lib/codeql/xpp/elements/internal/CatchExpressionConstructor.qll 3579c4950806ba16a24898e6541a7bc3cda31e35153faafe9c95503d14716814 c0f63cadf3e3f5d3e153c7d7d704e97540071049cd1028a198ef5d9f7d51ce2f +lib/codeql/xpp/elements/internal/CatchExpressionImpl.qll 445755bf87412d8b8c9c149e4265de7752470b2fe4f8d43af463d2faddb36073 7dd1fc142de657379e7a58b582a7677a376cb2a245151b0962e056c01a07372d +lib/codeql/xpp/elements/internal/CatchImpl.qll 852c3188f6ccc0d201ce7301f111cc61e23600735e2736585576046ea51952f3 1c6610aa2adb8f8fd71f74f784a8b3b75f383b173cade70cd558b829c7dfc25f +lib/codeql/xpp/elements/internal/CatchUpdateConflictConstructor.qll 40ddc46a4b4ed1b1a5dff736bfd8e93027abf5bd121054be2bbbdfddefdf9f70 6d754c83d399baa572bc96d905b971487997a5b7e29ea9d977584a68f50bfccc +lib/codeql/xpp/elements/internal/CatchUpdateConflictImpl.qll 7a4b7734f73b4bca8b65c1aed665fce3c8ab2f3daa37f14ac80bbbf4905c13f2 e98dfd0e3196cf20b0c0c379711da74b3c5f718c70737eea87df97be73d44dcc +lib/codeql/xpp/elements/internal/ChangeCompanyStatementConstructor.qll bf956706b927fa867b7124bbc100c021a79a5e98c6f41209aa030187ee26475f c6d40f0dcee69b3599643d64cc0b1d6426debb3e89a5018f0d4fb9da9372b909 +lib/codeql/xpp/elements/internal/ChangeCompanyStatementImpl.qll 7100749033753d8ffc2b166a43373007e53139eb2176b2bcb807e237e317a927 b835b5636159a7ae9fd894c51b0e18e296ca7d07589c82b3a46c00b8689d59c9 +lib/codeql/xpp/elements/internal/ChangeStatementImpl.qll 4f677dbb5edeec101803092b92b896bc51d72b75e7123ff50117d84a52011d2c 72f333895ee7054cfbfddae7e3805d28e5b12ba29a89eba7288ce87615dee728 +lib/codeql/xpp/elements/internal/ClassAccessModifierConstructor.qll 009b1e65226cb817673abeb584eeada6f9dac328627cbc6009dce3bbcbcb155b a1d472252190d1319fec6e39810460fe68e76a3bb05429b9b111e8bf3ced9d7e +lib/codeql/xpp/elements/internal/ClassAccessModifierImpl.qll fc6926782e4f9f961bed540bac87b32cbea6685025e66f460173d697428dd95f 6212d50c25002111b30f6bfdaee3c0f6f0a15158846fce1956b49a210aaa83a0 +lib/codeql/xpp/elements/internal/ClassConstructor.qll 48fa872f0626ae2c7b3d50e7a55062e1607b28070764300d788956c4eb179204 8103f09fbed9cf3a62cbf2a70b089718589ca0826c0096e275e63eaa90e99c72 +lib/codeql/xpp/elements/internal/ClassImpl.qll 4aa8579ddf2ee70439b31f3c437dfd64ec71382c2c2a32f06a865e8feac25375 7f25e6a3c6f7dbcdc27638eac4ae374d9494a75258cb9c035065a12d6d11c3c4 +lib/codeql/xpp/elements/internal/ClassOrInterfaceImpl.qll 8bc8ce51dc844598a357ac373ec41edf0ed1b819a8c9279737c56db1eaae6195 9e442803ba3f55b66eab03b299003bb6cabbe19ae21dc18aa46325bb1c434102 +lib/codeql/xpp/elements/internal/ClrEnumerationLiteralExpressionConstructor.qll a6714ed0974a623ca9a970bc39702db4757c07b9a093a26c93f04ddd6f883e0d f697879b31ea06f1324b0098ed1700e18f358ccf8b6534c9c8d5e324b19d9154 +lib/codeql/xpp/elements/internal/ClrEnumerationLiteralExpressionImpl.qll 241ff8f6fd3bc98df6729775bb1c8e640f282453ca886953e4e4935ed0271e78 f16e2203a27591b38da96c79d62e5a1524e93c1b97552571865cbf9edb9ed1c6 +lib/codeql/xpp/elements/internal/ClrTypeConstructor.qll 0d7cae215f3519b9174e2b6d0f89951e367ffdbb4d412a5ac5712cff8e5e44d9 855ad6b81823fdfbf6a5a3f63d896a4e609ae8c23208f5c0349e3120c913bee8 +lib/codeql/xpp/elements/internal/ClrTypeImpl.qll 2f6cbd5852396888002de1162a12388beb0d9cc67d1b00cd620b459be32786a2 1186a451ba1f34ac284dd518fa1f2e818b1fa6dd51c5e6928425ea0e1c3c494c +lib/codeql/xpp/elements/internal/CommentConstructor.qll 59431a33a617c7818819453c627d3936c67aeb0311e859cf09ded13f1a669016 14c8c5b3101dc663cf61abeb9eadc1c762332eab11477acb8d341f6261ba5be6 +lib/codeql/xpp/elements/internal/CommentImpl.qll ae11c55df904a436d1ab33fe4c601cfcdb17a80331407e1afc8ccf374654eff8 170e6697edecc7ab9f744f39e7bb2bd43b0e367faa4ad990c20ce018d9034e00 +lib/codeql/xpp/elements/internal/CompilationUnitImpl.qll 6a797fdcbecfbd984287aa85145ec3ebcabb037ef779e29ecf7ef0ac3dfc087f 23ae7e90e28132f16992df3dfe9feccdbe325ba6c954a0bd7494ff58f814ab44 +lib/codeql/xpp/elements/internal/CompilationUnitRegionEntryConstructor.qll 67470fa64cc0d240d5ba07cbd0a2c9e24772c7424e746a1e51997ca91bbae720 0cca3a7998e33ea6c0afa6fc18ad2e795e3b8d2ac434a00f88b5d294cba7a5c3 +lib/codeql/xpp/elements/internal/CompilationUnitRegionEntryImpl.qll 9a5d4f890930c5994596a2586dbcb985e15dab6b1e26b7de1fff23a4216e218b c558c599fd903a97671489e9d131c28979322a67763e12b34b56b3f720c75196 +lib/codeql/xpp/elements/internal/CompoundStatementConstructor.qll c8364c8ee5991694768e051561dc83e71b9a1bdb923af2157aebbd1b0861d90f cde41a8712fde10ccb92a9e0e274718336f28ce4ba550c6a0fda9693a35a3c49 +lib/codeql/xpp/elements/internal/CompoundStatementImpl.qll 5f4935dc9f0d04b85f41606ec65cc3749f8dd202d5dd0361b338fa61ef5fc6fc 3b9aae1c650f4b7e6501cb25d3b0d9c9d88276b60eb4e01c58a530554c2f7ea4 +lib/codeql/xpp/elements/internal/ConditionalExpressionConstructor.qll 6bb74d3b6c6192707562b0a4a56c63322138b546c49a6e28e78f0592110457b0 6e262bed2506deb120920ffd6e7b430aad26b3d9079624b739c95e8604419ed3 +lib/codeql/xpp/elements/internal/ConditionalExpressionImpl.qll a0f616600e8a120af367f491bfb0a74f6b5a78225446ac99791eb2c054bd0e5d c41ac4fba39b6da2fff022af2918be6af0a847f20b1057690a1fb76aed663949 +lib/codeql/xpp/elements/internal/ContainerAttributeLiteralConstructor.qll e0c37f69ee67ecf6c5c0cb84bd38b0d9482e3ef2c2bb996cc94c5d0af7c2fa69 a4839d427bb45cdb9f989775fcfaeea0420fe28c8b1b3969b38893dadb3dc2b6 +lib/codeql/xpp/elements/internal/ContainerAttributeLiteralImpl.qll bf1dbb81dd93d289108e988d0e00bca9cd86f70e7f94926b70f6aff1695b504a 81d87b261ecac31243c48f84f35cbe369cace8683fa0e1e31187f1d30eb06dc3 +lib/codeql/xpp/elements/internal/ContainerLiteralExpressionConstructor.qll 5713c3ada30ae2bef6043c6a4329286966367c05de95aebdf126c503d6f5233d 1f6a089e1eda8b51c0c9ea20a1b7eb365236be7f0779ce215d78b8ac3e6338a5 +lib/codeql/xpp/elements/internal/ContainerLiteralExpressionImpl.qll 75d0f527bd0497c3972ba061190548ab9c7909a241c64cc396a758158fa0d7b4 5d4b0c9da8b16a33d94122e2564fbf497d2121eac8dbc87c22705ee5825b77bb +lib/codeql/xpp/elements/internal/ContainerTypeConstructor.qll b3218df5dd829172c0982d8608b7e5eab1a0d576c6e0cc6533c6ee086cad388c da82592d5e377d195a984e93c9a0542109d57ba88248c5c25b325e00ded8a20b +lib/codeql/xpp/elements/internal/ContainerTypeImpl.qll 63fc29bfa6b0e7ae39b88378f93e2d87a0fa859b408d7ccbf62e0f679179027c 2c13dd2bc4f2d0accd411fd675e6bebe25c4a33d52ddf5ee710cb989e385768c +lib/codeql/xpp/elements/internal/ContinueStatementConstructor.qll 931730d980c2f59a3c4816f11937db80b93c883d64d6e32381d0eb3fa60ed5e8 9a957148f00b6aa21f9da1d25a5c17b51500f665b195ebd07430dc00713531ce +lib/codeql/xpp/elements/internal/ContinueStatementImpl.qll f9aeb42307afb13fa48cf07de5bcc6bc557170b8cdf890271e7773b29620cf44 ebf372b3673785980e70d08788e7b62154e283ef750781c85445ea7aed758a33 +lib/codeql/xpp/elements/internal/CountAggregateSelectionConstructor.qll 41e1fa2058e7f3a53a720709d2e2c896d477e6a43404acfa886a21febbc798a5 cfb7f2108065a126bd2c1d5c5f9bb73fffc29441c82f697de351fa3015af2e88 +lib/codeql/xpp/elements/internal/CountAggregateSelectionImpl.qll 8501e4f6a3c20b49b8bd4b491eef5265584950c7380f8fbcd4e5487176675488 ce9384ade71a749feb4d85052c1d0061841b4a753ade20a085db4d9066fcda27 +lib/codeql/xpp/elements/internal/CrossCompanyAllConstructor.qll 62ef397fe39bf925b73944f7db2c3489e2113b660af42144c0b3ddb48ce5fbe8 4c5fbfc76b12694c55e38491e73ae84c7f311a864e1d8fc6605b6153e5a57247 +lib/codeql/xpp/elements/internal/CrossCompanyAllImpl.qll c5d407157405bb0e8d159edabe29c302a03b35ab46a9dbe5011dca92738c1b0b e1a4fe293be99b3bff9acc8e00c9c1f499fce4a917f4a35983f1971ee5c96850 +lib/codeql/xpp/elements/internal/CrossCompanyContainerConstructor.qll 813158459922280e33f358dfbefccb295119bd51bb365827172666c61f6aeadf d41f3e3e4c7a3697fa70748b73800bd98d61360eac802be7f999ba8cd8129bd2 +lib/codeql/xpp/elements/internal/CrossCompanyContainerImpl.qll e9921dcbcf61e6400abbd226f599bb44bde7b643f72e1277ca0fcf8ca5198032 f29b579cb4acd66656179d6b3884de357d3880a0eb3fbe1bfede5dee11159d3f +lib/codeql/xpp/elements/internal/CrossCompanyImpl.qll dd8c6135b503df81d2c1fcaebfa947ade7f5f2cd0a9644ec5cf4c2b50e7cfc57 17522f881fa102e9e4e337005cbfb77dceafddc88c515199c51ae935438c86eb +lib/codeql/xpp/elements/internal/DateAttributeLiteralConstructor.qll 70a15a4fde5d9109341df332ebbe92f0b55e290609df1cd4d7f6c3eab070613c d786e678657da86f8bdce6fa4884f1c4e747a4f4af15488572cc23824e3ac497 +lib/codeql/xpp/elements/internal/DateAttributeLiteralImpl.qll 29d2433ebf2ae0538ef01405f2c7da487e9554cc4d0640cc74e1a5e29be37e6a 408697d5f73d35e30a76506f58ac3fac51d6185a573be9702edd7a5b15de276f +lib/codeql/xpp/elements/internal/DateLiteralExpressionConstructor.qll 4925ceb8893808112855c8149d7a80ec519d12b286cc489fb4a9db1767441d50 ae260b92481c630719ff426048d9f6193507eff3bccc645d709d0ce42b2f4281 +lib/codeql/xpp/elements/internal/DateLiteralExpressionImpl.qll 99f143b56ba794a6f3951b8e9b0881d568ea0690fbcdb305bc3409dfdf35f508 9d36a42c0a959304990489677991cab6903689b5177cad30787d6888128921ad +lib/codeql/xpp/elements/internal/DateTimeAttributeLiteralConstructor.qll f4eabd3a008f2a43eefcb47fec4ccea67c9f23b35487fad34f69bd665134a2b3 4dd7bb4eaabf88d99ad12d7c485ad1863fa6766422c9c1bdab2fc8177b7c6628 +lib/codeql/xpp/elements/internal/DateTimeAttributeLiteralImpl.qll f265d9cfea6c94c1aff57f602e75c176e1c6246df59299d14bf629a663b60649 115077f0ab5e1419570c9ab23aee9cc55ba3f1fecddb60731fa5253907d411c4 +lib/codeql/xpp/elements/internal/DateTimeLiteralExpressionConstructor.qll 058ea8a3e9a57b31fcc624cb92e0deda6a9c9c8d21ef2a7a5664d3e114a62538 7208839fe2ccc56093e9eab91e9c965496882ee0d14f2a575e955913ebd798ba +lib/codeql/xpp/elements/internal/DateTimeLiteralExpressionImpl.qll 03d7fc829fed8496f4765538b85b2a970751668c02b42491529710b2cd63672d 725907d849b9b5197385209b4ae6bece70ab5a004ed743338d1f272c0c6a2447 +lib/codeql/xpp/elements/internal/DateTimeTypeConstructor.qll 0bb994bc019bdc72719bb784327003eca34a737c438a9754b8b6521f9d6d2ded 316cfe505132145d1c024636e53ef5b36ec896dc688b5a4ffed0d29cd3e29438 +lib/codeql/xpp/elements/internal/DateTimeTypeImpl.qll 0f098de2a06b24bf678124511b2df077b122f3e18fd69e76576b44c651900511 6eb4ba5c40946f0e874fd4256512077785d66ac83072da09c22439624c9500a6 +lib/codeql/xpp/elements/internal/DateTypeConstructor.qll 02223f3e6c337dd436c10ab185092998d552eba4df3a5ce1e9f032d12d12e889 b7b0f7245a2e828b4a0705520852f81b6641a103ee0d3ae50c0fec737ba96821 +lib/codeql/xpp/elements/internal/DateTypeImpl.qll d50ba74b5c9b4cab66206d5807cab08a77e6afd841f7d947861a8e51015d1d1e 246d3436b34592346221c4300da4086b0bc7c6cc4f07e9e61e722ebdc21ec483 +lib/codeql/xpp/elements/internal/DblAttributeLiteralConstructor.qll 35d8155272e3bc2eddc0a88397cb2b68595bac1471925137caeccb9aca4829a5 8fe892df4b112d4ea05317ff7dc5696b78e66f2cad3c793712be4a00160d1504 +lib/codeql/xpp/elements/internal/DblAttributeLiteralImpl.qll c68bdb7a9f690e8fb956b7c500c29ad9652bae72139394d1279d93906e58db59 216408d074a98afc8ae2251d465a4f50695e980bde9bf7f984be61803bfd088d +lib/codeql/xpp/elements/internal/DblTypeConstructor.qll 209e57b03421aaeb4dcaf470bd5247004c2f9cbd742abeb541b35c6e36cd974e 12784d75b65e82c6afabe590c0eefcfee72aca6b54ab6603a38bf35953feb17c +lib/codeql/xpp/elements/internal/DblTypeImpl.qll eb2c36607e6a24fc6b67106ed5a937989fd63afe82238e93c2a4d582de0abcfc d6479281d17d7929221fb2828edfbc5ab9302fcda476a269e4b7bb3bd9c3ec89 +lib/codeql/xpp/elements/internal/DeclarationImpl.qll 52b98375e606aa3abe7690869592ba64e9a194024cb6d31b348e6924a12ae926 590d4a3de013ef024c4441d8eefe89e4c3ee98619c6f6414aac9be009f274ce9 +lib/codeql/xpp/elements/internal/DefaultTypeAttributeLiteralImpl.qll 53608b6cee1db18a1aa8b3fba6b709d77c40f74f33acec80fbe7e953d550dfed 851f5f7e84e4d1aa564671dbe15b070ac9a64563097616daae5ea90c58776b52 +lib/codeql/xpp/elements/internal/DefaultTypeLiteralExpressionImpl.qll 3d475bd12fffb665a81638d35d467693d15684a534ce796ea921ff1eaee209aa 718abb242c00511d3acc77df4609ba6d9d8466f45e608ac5e051c32e4f083f32 +lib/codeql/xpp/elements/internal/DelegateConstructor.qll 009ece5031985c38d3e29aca35a5c51c9e38183b01b83bb29db9015e2a13a22a 2dcdec65f721221c43d2d0dae6e043266f3cdc3cb571e434f08eb8d8a42aef55 +lib/codeql/xpp/elements/internal/DelegateImpl.qll 92fb570af823a5770de4c949ead716c55c10283896da020a1a5c07a732b5e08d a38568493ed56559d690dabb3f35b5511fc7cc06bb6da2510ec2f0dc98c40d39 +lib/codeql/xpp/elements/internal/DeleteStatementConstructor.qll cbc3f6518f44543dec6fa0407205fe349d6329330353c85d63affdeccc1d1101 f2668d04027e40ac0003527fbf8316af484b22fb44b24f27b3d50e30bb57aab1 +lib/codeql/xpp/elements/internal/DeleteStatementImpl.qll cc1c582601104cddcbda546e238d77ab7b8e7faaa939b1786de8316e8f17cb4c 53de8d2c0ecdfd89a0da899d843e702fcf0816f0c7c06d74487d9c64fa246a96 +lib/codeql/xpp/elements/internal/DivideExpressionConstructor.qll 363939673366f6e7a627110212322abb2b560041aa454babaf1e60e7a212752d a7febb2426bfd3412d86ed4647bffb5da6e0845f5f0b3c89c062e7fb37fa66e5 +lib/codeql/xpp/elements/internal/DivideExpressionImpl.qll 1f671b64c9209379dbb289b39c797c5b086cc20c34cca4f7f2991d76beb85b28 fe02a75f38f1b2cf01c4f269542a28a252d32128df7289927d6cdc8fad328505 +lib/codeql/xpp/elements/internal/DoWhileStatementConstructor.qll 57701285f43f76c3466966f4a136b9c7d032dd81a25ac4fb8ba3d970697ad1c1 e9cc482319faca9e0dc5d393086a36d1c4e454a6c41362e524f46aad55fdd1bc +lib/codeql/xpp/elements/internal/DoWhileStatementImpl.qll ae0ccad40b09dff96fc7fb6bb16b6ea92cbdc70281ab678b53c4b6c3bcbe90a6 e81a27ae4d590489de9031073fd5fdaef7bc38a5b24a21ba662dd8d893af4409 +lib/codeql/xpp/elements/internal/EmptyExpressionConstructor.qll ef6623472b764640a6d19b02a5c7dfbefb3a69486c92c3c6dd2aad6da96c1a2a c7b053427ab351aee7a09c792ed5aa5fcece8506170971f70d6a9dce38806e2e +lib/codeql/xpp/elements/internal/EmptyExpressionImpl.qll bb07b8e87773e5d3a12ebe579f2e44b6aeae1f9bc916ec9da51d234facc1d97f a45b1227c8b00fedc18b3a7bde754bb194848aced12a6b78e31725c2d74b4ea3 +lib/codeql/xpp/elements/internal/EmptyStatementConstructor.qll 1f03962838d4c357e4d3ce6242f51b869a1a690dfae3277a802057902f2edb68 4b18e689d29988e1eb3b17f48e9f644f3bd5aad5a91b7ceb39a16596c3d5a76c +lib/codeql/xpp/elements/internal/EmptyStatementImpl.qll 1a627de968a2509d3a2e71eef655c6fc81d3969a7f8f1eae5b0f1907ef6f8019 fbf3b10bb9569f34885bc3c9e315710f7352a5605556de60fc3e47bb6e99c4c6 +lib/codeql/xpp/elements/internal/EnumAttributeLiteralConstructor.qll 6953dc0da0dcbeb0301383afbf2f5c1d9134b4d58051f223a3368b3a465dcf47 1156de1581ec47eaed2c2543648bd333861ebba00f041b16dbb56196bbfdbe78 +lib/codeql/xpp/elements/internal/EnumAttributeLiteralImpl.qll 7c33318b9aa282bd485fa8bd97197c7d605d4b550c0464479750545359efe25f 719b963a97370bd2e23ecb8f5e384a6d7f9e9b8d43806e190682b8f4eab82853 +lib/codeql/xpp/elements/internal/EnumerationLiteralExpressionConstructor.qll 66f0177b9f714f38c2627a89c710cfbc1d1d829edfd3a9839d321c778eaec3cd b83813e1dd1b774fb30121a9e6d51d31337a0ac4b9007d38b13b05293af6d491 +lib/codeql/xpp/elements/internal/EnumerationLiteralExpressionImpl.qll e4f4b2e14e3077369931f7f0d298eaecc79a6fe06883e7fbeb3240c1387aaee8 cbfbdda377d770e80109e79bae3b487aab4b7d834a5a96bdea4da028855c0935 +lib/codeql/xpp/elements/internal/EnumerationTypeConstructor.qll c0e08ba516de3492badd5568d4a8ac493c05199713afcfb5e715e82f515d8135 4deaa7165da0a3969b2b56ea2fda27d911a60dc8426b1d2ec2ec383230efb963 +lib/codeql/xpp/elements/internal/EnumerationTypeImpl.qll 355a9c532350e753b8da95e1881fa38c6d5f8e89235027036bfd895f40db3eb6 1cbeeca2251e3f0a95ef53efcebe78d198b880ac23f5bac258cfdb2dd0f9c938 +lib/codeql/xpp/elements/internal/EqualExpressionConstructor.qll 138234b9f61583ab5626587f08d95316687f43b56bea1d3b1414f414860a081b 4d8bf405d667ed8dfd24541a2e280480fe380d9148425f115390929bc3d5fa3e +lib/codeql/xpp/elements/internal/EqualExpressionImpl.qll c11425434d53cc7b54d1ccd01206329d609a1498310895a91a26862b1783d404 16416d3eefced9df5b36a5028f7761de78cf4fbb4eb24ccea4e8aa0d8f28204d +lib/codeql/xpp/elements/internal/ErrorElementImpl.qll e411422c57380daf9ee5aa248bf94038cf07eade9a4827757026a4f25626cd18 350c21ca33204d6335cab6270bd3ff27d12b0270f1f84240dd0bcd6a56572a13 +lib/codeql/xpp/elements/internal/EvaluationActualParameterEntryConstructor.qll d302795c9842c52a91fe920c11a9509157809b75cfdc3161679bf0c94ed4c1c6 7443161fffb3bc3ea1b8afd4d89f796672dc0ca42fb20ebc85cef2f178611230 +lib/codeql/xpp/elements/internal/EvaluationActualParameterEntryImpl.qll 62e2efa34dc92b7ea744dbb032787611aebdd56fb1e988f09f11fae7f2fd1345 9bb6afff73357d991e688dd33e916f2e7d322176ee321e69b496091e3c7b1aa6 +lib/codeql/xpp/elements/internal/EvaluationImpl.qll a9d8a9559c2c238a02c9aa6a01cdd4d75506f6fe8f6e2ebeaec191001c83697f 713b0d3ffa922a5214eb11516b223252da4d73574d2bbb14bb0a3dc06c9a6e43 +lib/codeql/xpp/elements/internal/ExplicitSelectionConstructor.qll 9890184023e90eff847be4378e5cd8abf3b69dc8cae8469b8380c8d81d5e326f d52d995b62228829576711f6e660cf1169ee12d5ab76cf2930101998a25e342f +lib/codeql/xpp/elements/internal/ExplicitSelectionImpl.qll ada6628402826a6688d2c42c5f8315689a52d82f4107f9ba80b4b829f7ef93a4 9fd1508f52f0f0a7fed715c551cc8ef2b4c1265c01e123c46dcfd35ff35c5571 +lib/codeql/xpp/elements/internal/ExpressionCompilationUnitConstructor.qll df0b81aca5a4939d78322eff1ea30ada66c63cb83503a81adad04f0aa5619602 6467a460446714245222e45c793f2672e36abda1b86c3a8a7731728346c17f68 +lib/codeql/xpp/elements/internal/ExpressionCompilationUnitImpl.qll 7de480b164c409e9c0b89942a52c5aec89c4529d85e4e80f35aa23e7b335902b 8f060864db04122fbf88faef70b4674e8dbc7e3fb4c23f31cfbb89ed9619d7ec +lib/codeql/xpp/elements/internal/ExpressionImpl.qll 404694051edf694a2d4453e464b606cd30adb72c015153b156dfd4a853e65000 dc87fca3064f7de481adbd8d5c381a3730a014535a0c9bdeb16cb8e95371dd25 +lib/codeql/xpp/elements/internal/ExpressionQualifierConstructor.qll 330b01c4a0a847f6fe5e94e2672bb8ae941ba709326abc6386607ae80ae77155 d919081a25aeb90ad2c0f58f4b23154ca0fbb7ef4f40463609d6f9961d7ae7f6 +lib/codeql/xpp/elements/internal/ExpressionQualifierImpl.qll 4d274a493fa1962e68b8672bb35e70f1ae10fafdc21e4e732037d6d6449453e8 7b7462458b028a97c973b09d7ccdd8aa9cc6992047886a6b1d89efa1a23a96c8 +lib/codeql/xpp/elements/internal/ExpressionStatementConstructor.qll 41b5dc5d29e5dc56bb91c406462db513895c945961e8beeb5325b2cda25218d0 ef6b20351afc72cabd978372ea76673b4a193317589bcfd515b64c0d0b352b1c +lib/codeql/xpp/elements/internal/ExpressionStatementImpl.qll 7aa8273a33696540bd7c58ac48a1faa0ca700754d5b5adf2f1e87008ee6144ef 5101aeb0ec973615cedca3f150972cc88de69868a9ed7d88f287427b48f14a5c +lib/codeql/xpp/elements/internal/FieldAssignmentConstructor.qll 8623ae0356d5aa0749f242371035aa2932ff40dbba9a45589b68287dabc2cd1d 9b7cd0f67ec17606c83fda975b26d782a45fe87d1fe7cd538ec7a3bcd8c6b7bc +lib/codeql/xpp/elements/internal/FieldAssignmentImpl.qll 3342f6df98973f50f8f49ac324bf0b8fd8bb191e43de03884b42cb19d5daac98 14ec1c83ecf0195e496650317488f39c9cb1dac010967e8c5b608fbb01050108 +lib/codeql/xpp/elements/internal/FieldDeclarationImpl.qll 802b0a218c7b0b6063e94db1d147f6a5130cdb7f28d4da1063f051532e374b66 98e57d8f06a5e4bdc5b408e84821db6066294ba65137ecdada2d79806e526a62 +lib/codeql/xpp/elements/internal/FieldDeclarationInternalConstructor.qll 83ab8db8b016b9c22aa4d28e758a434633f37e23a8a47473e93656eb34649130 dd308ac0b604d055f046c3b6cd6359794569d10fceab4459f1dd60595c0ef17f +lib/codeql/xpp/elements/internal/FieldDeclarationInternalImpl.qll a2dabc1d906c53b52b44f0742cc7d22de345da0c51da93de3d496118c60de19b 48de69f8152ca1843edb353d3466d507834897cfea8dc5c35e0660439458a8d6 +lib/codeql/xpp/elements/internal/FieldExpressionImpl.qll 4dd02c59b16c1bee5c6673226f16fe2d6fb1dff41c0f686dc8b65490bd70e00f b0c92ae2827b8057a25c17f2bb8d6523c5fd7d93751bb66616f93b041564c2f6 +lib/codeql/xpp/elements/internal/FieldExpressionInternalConstructor.qll 1c97d43a62c187f315a773f45429e59f45cb0611d11f9ede4e574abd73f591dc 249ec1602691c74c1f06aa9ed54721a24e1550bebfb90a6c545600796a17093b +lib/codeql/xpp/elements/internal/FieldExpressionInternalImpl.qll c94a7cb72178ab822dacf21d9d3948b92e1e1b6c04693bb414995ace5d794075 50c56d34849c0f92d621197b76d1b36c82e1bcca3f3e63413be5fefe4c9a79fc +lib/codeql/xpp/elements/internal/FieldSelectionConstructor.qll 11d7c713ab19f46ed0e785be97bf22c1790e00e28b48a4be62723d8136f35dc4 4b284ed972bcbb70beaee6c4f33e1abcb6cdc6afeb48f959c7f3d75520cda4fc +lib/codeql/xpp/elements/internal/FieldSelectionImpl.qll 8de8b67cbd61792a72681dd0577cb9b9428e3c24142bca2499b5c288b691723c 0cc4880ae59a14a559328fde390da24fec86370c5a2439f1adcc59703af246eb +lib/codeql/xpp/elements/internal/FieldSpecificationImpl.qll 7347a2eccd05f1fef2c589ce6961606a2c6b846efbb14e23c99d71a8412d13ae e10eeeff4e8fcb6fffaf41febbbcde52c8ec260bd092d29fd486e4b73eab5161 +lib/codeql/xpp/elements/internal/FileConstructor.qll 14a03c335fa6e6ab8dd3411d7c30823aee35e2839f592456962c1c606172b4e1 e47e24add65a942a874d7d8338b5b9deafbe05141d3afa4a79191fc990998388 +lib/codeql/xpp/elements/internal/FileImpl.qll 462476017c7fc9446eda5ceaf372500883dd656f0e9c37b9e214047005a6dc4f 09c0691213f7a5dfbb76c357e2ff4e2335ade3786eaa67cc6aee89929832343e +lib/codeql/xpp/elements/internal/FindStatementConstructor.qll 6977ba4efd9cacda7fd7d8a0bd4a409e078e6e2c036e6d6bcfad8ffda3b7cdf8 3636807b8fd105ab96e39971147420f3fcb8b584ab862c0b847b523c5a9b474e +lib/codeql/xpp/elements/internal/FindStatementImpl.qll 5fe3560638fba2272815586b02acc7b75dc3f1d6ef190bbe931d7d2dbbc3f768 0a4d3ff61a99d96e39663e2e66a4344772d5cadc8829a0fc86bcd121daea90fd +lib/codeql/xpp/elements/internal/FlushStatementConstructor.qll d9dc3fbc0e8d43929a898216426e316eb242709432c4cb45834a6d795164518f 88d18b18ca150c7ae6326605aa0752fd1f6aa53890c912e484cb8812f743bf4d +lib/codeql/xpp/elements/internal/FlushStatementImpl.qll c8973f391de5876d0ebd714be238ac4fdecca0a75e78ce0efd8db6a4c22cf3a9 076ed71f76996eafac05ca65cdbad3204a06e37d193de402e5b9b5d2008085c5 +lib/codeql/xpp/elements/internal/ForAssignImpl.qll 7dbddc579d18b613983ca5fdf661865456f33fd2235eb04de9c2b64e98bf4f84 3e8709f20fcef52611509fb4765c236aeb8d81ddad5ef412516b7d7706d7b2c1 +lib/codeql/xpp/elements/internal/ForDeclarationAssignConstructor.qll c6a90f1b80878f719594d027365f51081cd219fa35eef6aa69397034f10cf7e2 15ec9e8895a2e58d6da205b129832ee6d64ef83337f37ddf6df1de5ab2db800c +lib/codeql/xpp/elements/internal/ForDeclarationAssignImpl.qll 0e873721f6937ddf6cdeabd951df7356382b849db2af5948e2f2fc5c91e353ed 28ffca5ab8d62871cf4b0b56d2251246a85b790c81c9bd7a923e529a92a67a4a +lib/codeql/xpp/elements/internal/ForExpressionAssignImpl.qll 5f58831cb9db5cb84b66f4e1eb02ef393a68dd680f94c34984f9c70678b7dab1 be810b2aa949dd48400ddf229e06098328baf3df5bbefc5f6f64d7a06f715f3d +lib/codeql/xpp/elements/internal/ForFieldAssignConstructor.qll 3b0dbaf8fbc78a5c13471826a6dd71679f54b784183384938c9b21e0287c0379 1e51137b0b5f1b67b089ac075cd3ada191e7cce6fa5437a049a8932a40990a12 +lib/codeql/xpp/elements/internal/ForFieldAssignImpl.qll f96cdbc2e17a68b81ad382fa392b9591c8a426ea515d94356886156089817738 40886c81d48f913ef474d889593931e88cfb618d397fff7adcf9b09aabe80287 +lib/codeql/xpp/elements/internal/ForFieldDecrementAssignConstructor.qll 9b90f78aa58fa5837a6eecba2967e414cb84742b8ddaca6ce45557de4772f9f7 a379680bde37925f0c1ab63b3a0d83855e64e18c9aaca24de76615797f0d5d2e +lib/codeql/xpp/elements/internal/ForFieldDecrementAssignImpl.qll b58094a986a5683d6d77c0922e8741583b3172950bc33a3c4703b56dbd393ef5 67740bc30d5a254721eba1bcb6bce3cc2c8b44c14b256543fe9b09465010e577 +lib/codeql/xpp/elements/internal/ForFieldIncrementAssignConstructor.qll 85e185fd2068f01c75fd2b544df7659dbeaa18f8b89ec8622483d6430dafacc7 2165d2b2db986e3b41c86880b684f1969f570077637149eda912da4ee318efd1 +lib/codeql/xpp/elements/internal/ForFieldIncrementAssignImpl.qll 0d8a83f0ce0791383648a175a6f4fb0e73f5a87d7cbdc62b9d0024016f2dddff b3b26b9e01c819c2bf50d6d86349b426b5070792cf71c59993bef497cfeb8df4 +lib/codeql/xpp/elements/internal/ForFieldPostDecrementConstructor.qll 4c559aad8154c81286bc264758210e8b6c38c3fe0a0f654a0403b3b59836a2a4 f6efeee00d70aea95427053585a65d284cc55a3865b92949e78873fd8a21fb44 +lib/codeql/xpp/elements/internal/ForFieldPostDecrementImpl.qll e5ed7d809f2e615a99da05a864476df8da73c6f220bbf1e97783d00a2c77bd80 79fb91868d365f121da01c66877232d9607c401b20779ed92ade3e0c85689f8b +lib/codeql/xpp/elements/internal/ForFieldPostIncrementConstructor.qll 73bb4f0657a9ba6bf02fd87c1a4b1314033ca3719175879e065052557976333d 96b81fb40db3bbe58fa64fab9979a307851a3923b0dc63ea508fa5c93fa36b2f +lib/codeql/xpp/elements/internal/ForFieldPostIncrementImpl.qll 0da446bd1fb5d1ff292d2dea3fa2f1dbb647d03a90fb09101a8b519d20c1452e 11a10a2ce9d27535b1bbed26a4090627efa94eca8f8453e299bb4cb1e5b77086 +lib/codeql/xpp/elements/internal/ForFieldPreDecrementConstructor.qll f5dfebca1f67e293890a02a0c0950e6bde7befba728160713ac3b017caebbcd3 1da193392448f49e8ce6783fb7909a4b42fa455e0bf0fa00660f5022c51cd2a8 +lib/codeql/xpp/elements/internal/ForFieldPreDecrementImpl.qll 239ff67a7d8d4fd986d3763b0c51a43eb27e4384ca1b4bc5b200bedc6912ae13 f91f597ab4234fe0ae4b8b9cc58b24aeaab02a755b338e89c997d3f4f294cbab +lib/codeql/xpp/elements/internal/ForFieldPreIncrementConstructor.qll 6edfdddd058bf8875d161e25c425b4a7f90ce9539e4938ea4785def3977fb06d b81493ed41bd1f18d59497f410c9454e11061fbdf21c8b71d8dc3c2120c08c26 +lib/codeql/xpp/elements/internal/ForFieldPreIncrementImpl.qll 4f350fa672ad2c8f21cd64b72ec1f8715cca90a76d9b2cfdd3e471807faabceb 956c8614f9d2b54129a884c5f3dc0b9090c996b3e606d429eced702d1ea83b14 +lib/codeql/xpp/elements/internal/ForStatementConstructor.qll 478fb996f177e81d61d4fb68f3acaa2571bd1e7d133e77c75a513e5e56696e5c 58a74f88d3c7f8a05e0cb9b9e5fb4ed3fb9da9fa525c8883b15c7f79e53c5afe +lib/codeql/xpp/elements/internal/ForStatementImpl.qll e44344b8f0ac8629cdb9e4bbb287f0215c5941527edefe7099b49ddfb807e13b 46dd57ed564ae1bba716d5248b76ce1078b25a87e0d2f11cc015e144134570c6 +lib/codeql/xpp/elements/internal/FormControlConstructor.qll cc9eb4faa33ac6db35d33e3ca884d705457ac504b77c10af3b621bb51caf0063 4c571ae5401f999d8000b72de64271c242a386c75f01f3845e6e8a8b33704705 +lib/codeql/xpp/elements/internal/FormControlImpl.qll 0bf88d8f4e0509e6b2b6df923cac6e1991cfa64b51de8572b8c4afef51b6e225 c38156baa2fff56afdc43be1d073172527e711bc165a205cf2789ba61264180d +lib/codeql/xpp/elements/internal/FormDataFieldConstructor.qll b641d277b38e2ceb9309dddd3ddad0e559f86e422f5bfd21ba4f190cf0bf963c a6082e0dc556ac8fc013066069657080c3d0017e68196e80f349006f57e8da22 +lib/codeql/xpp/elements/internal/FormDataFieldImpl.qll 9b2c5f1ce1b96b7c1461caea73025da999fc59ccf9f3a26605f82f155f490cca 3e575e70e71cad8f2f02bc9170391caeb498bcc5078cfa86a813f1a8661fd342 +lib/codeql/xpp/elements/internal/FormDataSourceConstructor.qll 4113c583058bb28434337a7c53c8aa7bd6175602ef2345778e8595f3156d828d a664ced492dbfdd255b1d91ffcd5a088209a2c3ee795f75238733ba47a9d290d +lib/codeql/xpp/elements/internal/FormDataSourceImpl.qll dd3b1843ef83b5a76aa90d7a0639f335f6c19f4195964c288b675f95911a0eda 87d9a850970012ed0997bc4eeed7f12bc2245e37294b74d9ee9b1054f5f23aa5 +lib/codeql/xpp/elements/internal/FormElementTypeConstructor.qll aafd6d5408f8decf6621e1e84c356f0c1dfe8fd972f14d95570be684c830b974 b9efc22d76927d83b5429b4c99311910320b3f60876052caacfea37fa47a4252 +lib/codeql/xpp/elements/internal/FormElementTypeImpl.qll 616498ad838e1ec7c49edf1fb16ef2b235ff0d28c57b50e651466d612d9ee7df 5683e77e9e3cd1ce15a46574de4d813d2834a40cc44845dd9d718a2026e81e22 +lib/codeql/xpp/elements/internal/FormModelElementConstructor.qll e1f6e01873d659b023039ac461ebfbf450521ec19b6064a0256e11cccf480316 b562c8afe693c26a5355ca22f3966485a6548125ceac237875a06e2d305ed834 +lib/codeql/xpp/elements/internal/FormModelElementImpl.qll 97319042b90234965feef8baeb10694a99e69fd5f9596935c75443ee1d1261e2 6a15a9d48ebfb8700038b3d8d486dd2067c5f5d4e379537c055383409fce4490 +lib/codeql/xpp/elements/internal/FormNestedElementImpl.qll 6dd318f38b2efdfaea38aa5cb26e66b5eb6b63a84d3de5ff59851e482f370d04 2246d9be79c436f099ae66382d3d015b57791332d4540bc2ca21c80f95ff3813 +lib/codeql/xpp/elements/internal/FunctionCallConstructor.qll e943e237da2569fbea6b15b0663cf6d1fb2aae4a918e70a60e382a36faa420e0 93ff649a5fb922fdf23c2aa94f71538fc78df10978457e731045b2d4c96b17e7 +lib/codeql/xpp/elements/internal/FunctionCallImpl.qll 672a6250e7b943f4580e032c4e849b8a2c83be84e6dc4d6a708adcd19e6b329d cb5c34c2f62c82d216b61e0c9ddabbb243ede19b42e2b247caf7ea6fa2e6ad2c +lib/codeql/xpp/elements/internal/FunctionDeclarationConstructor.qll 8bae073c81f579b72bfcee3d1538ee6b4596ce6e1d45231013699bc2b04f9cca bf9c6fdb10e90b7b5c2b0bcd07fd96f1e923c38a2bd465e818348f8f7dc13b13 +lib/codeql/xpp/elements/internal/FunctionDeclarationImpl.qll a1e3733945c04ad9a2ff17ceda096e7fe308be4f5ec92647316e2dc3ef098d69 0906d34c519390496ef5f3454d028680e03c876daec5c98ba5f4c2ab5778890a +lib/codeql/xpp/elements/internal/GenericEvaluationImpl.qll 0b92ff226addf29e309d8c264468432c8510a136e721fc6a1efcc386f42c3f8d 8d58956ade86ff95be680e0ebf7866f62921a5d83fcee591d12d153e6bd0f7d5 +lib/codeql/xpp/elements/internal/GenericXppTypeImpl.qll 48b00373b4726f55078c8517de821e152bfb7ceed482e8ffeecbf36fee16c659 edab14e19928ef61686c0c1e5fd8db96ae02f6fd2e312b5241178ce02a93de01 +lib/codeql/xpp/elements/internal/GlobalOrderElementConstructor.qll fee34fefcc4b954e2371493fb23712bfad2c9a5d4ce00e285ec23571b9671c5f 6166a6d22f7c144b4a2bcbe22daef28a706925a4d29d2068cf32a042d1fa3fa0 +lib/codeql/xpp/elements/internal/GlobalOrderElementImpl.qll 4fef2b2b5d16dfb0ce9fc1d1698afc4cb93bde673942064d3ddf3e23a30959ca 069ecd8563ba33db7754034f43905a7e449d669509404ff7ca01c3e5dd501d97 +lib/codeql/xpp/elements/internal/GreaterThanExpressionConstructor.qll 065ac743de13584eace2541700b0bbfbde0bccd254450543dd30c875a16e0cdb ac840499ba32d2d26bb4c52fa1a932ac10475a3d7d84a84185cbda86b2e97752 +lib/codeql/xpp/elements/internal/GreaterThanExpressionImpl.qll 2fbf0f5d4fc1df54c997f07d00299f291592c5ab240667acbe046f3d71bcdc86 672fef55eccae51431ff36a2dcd9f86b501f70e6807db2498c5fc051c88afd7e +lib/codeql/xpp/elements/internal/GreaterThanOrEqualExpressionConstructor.qll 221ce8043740813c439f5e59fb4c76f5887ed5cb91df903508baf9179165198e 67ad6ba7c7e4c291c711c6dfa48f1ce4733bbc32d74b2ca9c8fc94a93e6d3d48 +lib/codeql/xpp/elements/internal/GreaterThanOrEqualExpressionImpl.qll ee6aef272d490a58ba538d427d2cba326d346f573d8a073632adaa5a0cb9c7fa acb158c2675f6075f0ed4cadcb6c4caa0caf72df0eb7db4657c811ea2df9d010 +lib/codeql/xpp/elements/internal/GuidAttributeLiteralConstructor.qll a9ecd12a7e74f8037d67d3f03ee74029d03092de5c3edd6a2fdadb7b4b174598 92a0a475f789507f00a5450ad4bd3904bf8e41c8e9289abdd3bdabbec40f0e8c +lib/codeql/xpp/elements/internal/GuidAttributeLiteralImpl.qll 91716e54a958679d82f69067f34be29d728f1b3fe4b2e48b037440ba3eb8c8bf 1d6b4bf061bfad3dbee353d04f4a9fadd3b4c946585dd9b0983860046d057f72 +lib/codeql/xpp/elements/internal/GuidTypeConstructor.qll 6aedf3e27eb349988a91fa55420555baedd64e11cd135d8359fe4b9abb209881 d1b8f0ff2ca6fc1492c3c9037322eea79ee62ca99a5c340d948be73a7b24ec1b +lib/codeql/xpp/elements/internal/GuidTypeImpl.qll 7ecfe9ca7e9cb851d7e0e32d9e34d9bd032f16bf352163533a5dfd14be562c4e 7330db8a3dc1045b0a1bdf22d414dfae494459c95ec76f648027c4d4d4585883 +lib/codeql/xpp/elements/internal/IfStatementConstructor.qll 6d60d9d7b2bb449fff357cafcb2eba612f56d9ab30c21f0a3e1fc14d90f2499c 48407f1ce2cc7a425a71f2f2208604868cd2670917cec47582ac6c93ad2bb11f +lib/codeql/xpp/elements/internal/IfStatementImpl.qll 29d998b8a28f10d2be0be6b95861cde6cf29c1bb001a93f80021e870032da8f4 bfcd8332757c496c5f2b08a13e18fcff5005de60554e864adb2842125891fe25 +lib/codeql/xpp/elements/internal/IfThenElseStatementConstructor.qll 18a5e400e8c132f610c52e2f23feb6f49799038acb9662d107aebc456547e699 721328a499b7dd5e4681454b3402a429cc046089617250399ca7a0fb473cdecc +lib/codeql/xpp/elements/internal/IfThenElseStatementImpl.qll 33d730e8e32e589f77d385448f607db46fe964d853099998b4a21becdebfcdbd 08951e1e4332637835a8f69910bba1a1fb816358394d55057355806c098a8fc0 +lib/codeql/xpp/elements/internal/ImplicitSelectionConstructor.qll 0d74297895f9f09e415640b60e0398b5ed2f4f8fbed65348c772154ed1536308 f192436830a272a35797c1e43d975cd360c384aa9ed9105780e7ca067528fc6d +lib/codeql/xpp/elements/internal/ImplicitSelectionImpl.qll bececdc3a88b4208c5a9c5a0d9168851aba3b456772c4825b97d2f24a7260250 5522f7eaa3a2094eef4784e1cffded0073c650fc45cad6a570cd7e7127464a31 +lib/codeql/xpp/elements/internal/InExpressionConstructor.qll d9630f5b63d447aa2afc306b803fb4412fe5cb5fa035f06e792956afdab9d780 b25a21eaba1516e12d2728f657c96726991aa3ecf29399d3e0c5302ffda19d91 +lib/codeql/xpp/elements/internal/InExpressionImpl.qll 52bbca5c4605c23f0ddd59948ef8829a28fa6aa11bf93b0e7a529040be8bfb45 682236e66aa36f64c3eb13c4c5d1d4c7b6fd8c23c198ca9296de25bb783045bf +lib/codeql/xpp/elements/internal/InsertFieldSpecificationConstructor.qll 27f1507df07002a3f8984c7cdabbf831e79af2cfc26829e81a565b42b35a8620 04ed7a7878f280d5d63ffde8f9d97fc5a471ed19da866f0bfb9cf078a26f19e4 +lib/codeql/xpp/elements/internal/InsertFieldSpecificationImpl.qll dd22e9e8e40e2a2ba4c98aaace58555cb15bf27f0474e24e46e825bd629b7d80 919007594103946946d384c9c12f3de200fd929a407cefac2acb027f5baa9a7b +lib/codeql/xpp/elements/internal/InsertStatementConstructor.qll 00ff5b85b9638d5693e106a474ddac45579c2a2220092747a2cb3119d0d6ac75 04cd52267cce9168e25a2c4b7b235b140e6a5073a8178466071609bbbab228fa +lib/codeql/xpp/elements/internal/InsertStatementImpl.qll 08d7deef9aed328219890968ec2153a5cbc0860a231e2e4b0ffa7017c0cb5cce e86717b46ddba16cbfdd469c36f25e48440dc27570e60a3421efda2fe8d1c4c3 +lib/codeql/xpp/elements/internal/InstanceNameImpl.qll c61f5d445c823320e8a10fbd94f8e81946145aa9def147d6d64bb7b5fd460320 71a69cab48d5a86c607a81250bb920e16a12bfc6ac07673088d369725b8db1d8 +lib/codeql/xpp/elements/internal/Int64AttributeLiteralConstructor.qll dce972a41e9c8bec3cce21345dabbcffcea6c00b5f1d8198e1aa90e51e602f13 fa6f4759f8335d9921e217178ef792e66e1214f124863972bf02f0abd33d45a6 +lib/codeql/xpp/elements/internal/Int64AttributeLiteralImpl.qll 7cd582c8221d5bbf8d660efd1ac26828dc59007b69345c9029260f1e9a65beed f780477e52c2431b4ff19cd88daff530910f111a28ee152a436a45be5b7ed342 +lib/codeql/xpp/elements/internal/Int64LiteralExpressionConstructor.qll 852ee5dae0030c8adcbb987df73109495f03be708476f752ca1c13b8b0ccb08d 1ed00a59ec79b4b855f9ef32de1d56acef84ab003d45cca5b432c202ad1403ac +lib/codeql/xpp/elements/internal/Int64LiteralExpressionImpl.qll de3f5862789ed6a28c8a47385459bdb482ee4e4edc04abdccc24b116476c9341 09300006c701683a51c5d56047bff75e23620ddf9602388f2869e6658e115524 +lib/codeql/xpp/elements/internal/Int64TypeConstructor.qll b3f1fde3a6df5d58068acb49de3b4037823161a174c2a00b32f54f1357306d35 46db5f32925fe8392830b774c6e55ffdff2bb71d9a952b5109d887f65806c281 +lib/codeql/xpp/elements/internal/Int64TypeImpl.qll 99040abba092e5299a1cdced5718eb56e03628e548e31ac98f4c9b38e3dc56e7 c322492d0c16238aaccc7573b5d60ddc020a75c73eacafbfbb3727e034af5d1c +lib/codeql/xpp/elements/internal/IntAttributeLiteralConstructor.qll b5dcb8d61ba29d35b6e97b52aaf6ad0d01b37fcb6410608f7e9cdd3383a981d5 ba9f7e8da23dcaae65161a5dcfa94dbb502e8090e75e89cd7be2a1f8121f58ff +lib/codeql/xpp/elements/internal/IntAttributeLiteralImpl.qll dffd33d467c2cbdd343ff7d094499e1661fa776f24c95e7fc27b138ad0b71db6 df097fd74edc2c07731f48725f12bbbf524fec2a2f2a83b5652cb52738a269bb +lib/codeql/xpp/elements/internal/IntLiteralExpressionConstructor.qll 4978cb317f1f0f7b051f856f3a688445d2c2611ad6b400598c0811c04c0a2e54 61e2c28d35cc8c631f95d86ecf49a095bc5fd6b91d50d3dfb16dc92b1383748e +lib/codeql/xpp/elements/internal/IntLiteralExpressionImpl.qll 61ab07c101d35c2eb16024f6326bd1a588e4f10be4d4d7d2b57b3a8719054891 46643600da64050c5cf292bf65160117f5e9165ba3c36f28a507c9102a82f21b +lib/codeql/xpp/elements/internal/IntTypeConstructor.qll 08c1e1a763474dd1599d36e0abf3e5fbe61b9ed78037ab23bb4c2eeef14682c0 20e14fb58329d778cf27f4a328e440dcac4e00db0413b6b60af4fb625bc4d33f +lib/codeql/xpp/elements/internal/IntTypeImpl.qll 81836f00a4be30c327f4ad1bd03e90f3e4fb1acd00e9b2e1678a5cb97ac1fea1 5fa02bf2633c429d1a00bf91fab502a7015855fe5e3a23185e9be33d8157ebfb +lib/codeql/xpp/elements/internal/IntegerDivideExpressionConstructor.qll 13facec248cf82daff0d0eed53c7d31a4963a3b653dea16115172794ad4b2fac c1b1bd3528d86e365439234903db1dd0b081bba4acb9e843443a3d84e89735ee +lib/codeql/xpp/elements/internal/IntegerDivideExpressionImpl.qll 6b2560352bb6b09669643b0c674dc5dcedddf7ff33571a79e943b3904ea701e3 ac5b3bfa7a21814f2a7e5ee8ead70b0c2e569101a58b954af8a8f2554c6edb9c +lib/codeql/xpp/elements/internal/InterfaceConstructor.qll f1e8ed06e68c06c6ee3dc5c0dff76615c9bbf12e204d41049cff67efc27e8ca9 25c1a8950e1b70211d11863834ba777d751b1d35823810d13a59e51498cd36a3 +lib/codeql/xpp/elements/internal/InterfaceImpl.qll 5a1c5194d713badaacd7f7fea81ae1bb83594e7fd7c90a089848522a1c5bf342 bbffbd76f1cf1e4487b33108aa6a9a13c639d3f163ae6a6f9b14f7aa9d3e3e07 +lib/codeql/xpp/elements/internal/IntrinsicAttributeLiteralConstructor.qll 6c9f83033d96981ff5ec3c72bf382c724f4a9729ae768bf11fa281f89471dd37 a5bdc7d1746561b47733edf166135ff438914ec8bd87832bc21cbf7a58b8ade5 +lib/codeql/xpp/elements/internal/IntrinsicAttributeLiteralImpl.qll 752001e57ae0ece9f5f493ab5555cd48ee0f28f9ae61572f640481274aadeec5 184cc9ee804618c658b83d7ea8c02bc32d1147d834a3794f42d8ff1ce8524913 +lib/codeql/xpp/elements/internal/IntrinsicConstructor.qll 22031ef5abd6a924fb237a002f1dfc242c5318fcd809639314327b7d88059c67 937353b01d59b67dc037cf1a52880e224d41fe5b6e8a4120077081fc9f806aba +lib/codeql/xpp/elements/internal/IntrinsicImpl.qll ae0f2b019bce5a7f9d8ef173eab5b05f585d3cfedb30edde01922b7b55d1e431 50f5bf889ae096874703f98fc59738169975ead61021c95df941466c932bb8c3 +lib/codeql/xpp/elements/internal/IsAsExpressionImpl.qll 0a15339b69b04f0b9f52d3822db5899c99b5905680306a4264d882c68cb718ea 73aeca16ff32e52a6b87c0e70dfdbbfcaece35e810ab24aa2fa6572c157e4212 +lib/codeql/xpp/elements/internal/IsClrExpressionConstructor.qll f5ea6e5415277c640173e33fa038d82e9ac5adc67092c12ad340168e686abb0b 6c909cddc81a5d4f4816bac1a4702dbd1e3da85f72b6c5f03b108164978526de +lib/codeql/xpp/elements/internal/IsClrExpressionImpl.qll b9290fbbe49a89bc1bbc35f362bce4ca4853d0c300a2d13b7c7c25e8ffa5d533 2c053c91af13e34074b5b4eebeba9b8277c09d76b34a0fbd29b717a5ecf6b835 +lib/codeql/xpp/elements/internal/IsExpressionConstructor.qll 003b3f5806373fd7edaa015f713ab200dee352ac83104469d75d25d4d57cd246 8d3f4fbcafba3d4d4c504975cd79f62eeaaec37d9592796ac7b4e981e5c4090f +lib/codeql/xpp/elements/internal/IsExpressionImpl.qll c0b7537e5ddcb800d9bc9ff5e388aa60cc1622ef54878bfa3895ba77f0f7dcc8 beb6255c4d802740d59bdab5117d660775fb6ece07b7c691b6fe93251c663d31 +lib/codeql/xpp/elements/internal/JoinSpecificationConstructor.qll b18c01df493bd57ef10916457451d3a7b2c54e3747f61bd1ed78e4628502ae53 7edf99b2828018211a753c556882af390ba12e418c5d3515720762d6af7b95b2 +lib/codeql/xpp/elements/internal/JoinSpecificationImpl.qll 92a083fc7b7ee6ee7e7f68f29089d80d2221d4fd81c839adabeb4fb7a37ebbb0 b2fd07564d71ac9ced1224b94569ab63b281103b17176fa82e2c2d223fc22b89 +lib/codeql/xpp/elements/internal/LessThanExpressionConstructor.qll cb768068b61663dfa31b174cca31bd4d1fb81e0886057fa88807e2698b1eb0c6 365eb05cb49451e92fa590781f2598b0dc5dc771c4686ca932838bf5b884d162 +lib/codeql/xpp/elements/internal/LessThanExpressionImpl.qll 0ce17f0dae5aea95a7d4d7b6bf97b1cbacd8471010ea9bfd85f4a062eed4d0eb 9fed47ec9949ec1e10ed3153190d5d22849ca3c514e496b83430ae4e3fbfa565 +lib/codeql/xpp/elements/internal/LessThanOrEqualExpressionConstructor.qll aaac0c0f3e49c8b60d86433c4079046c89e81d9c51419d8016604400fb292edc c39fb78a2e44108239c49d2382054a594ff39c31488478a8afd4f068510d8c18 +lib/codeql/xpp/elements/internal/LessThanOrEqualExpressionImpl.qll a4fbf2867f99782d99ea6dc26626ea152c07c30befc35879cc3073d2518110d8 56b1e2987340e1b3ee20b8b5bc79acd1a654ae06dfd41817b8425974966aeaf0 +lib/codeql/xpp/elements/internal/LikeExpressionConstructor.qll e13ad2a42af0e25bafe11301277bb9e298019f324af5b676a519d3aa11466ad2 ac2111c65d2e1f3bf65014220b9fa178b45171843524fd193812668840ca4e50 +lib/codeql/xpp/elements/internal/LikeExpressionImpl.qll 3ea56139ea359a949f3e903b222048bbfe9e74c7b7273962e09b65276897b41f 91849577df1e1d28dc9d419f72a3a94b49022bf9980d1b0aca189912701de7f8 +lib/codeql/xpp/elements/internal/LiteralExpressionImpl.qll 7a4c9ff6c384aa3eafd6a46c72a2bcee2cb03bc8ce046524e8116b75970379f6 38a0b62bc63a98cdebb4236ec144161f264731025681e21c91cec7132b280060 +lib/codeql/xpp/elements/internal/LocalDeclarationImpl.qll b0484a844a1148bedaea0cf942276e1c63b81674bbda14c66aefa9e93cbcdde5 20b13fad8085cf908fc2fc1b1aa20e9d89dd34eeeca400341f895aae84bcd2e7 +lib/codeql/xpp/elements/internal/LocalDeclarationsStatementConstructor.qll b1b878046aa85be24168cb427b807da99862dd224ff737f2a26a92f85e890514 a0554c16f4fecc6948c160e3840bfa46f7ce9732fa69fc74b9a75d0c6f1b0dbb +lib/codeql/xpp/elements/internal/LocalDeclarationsStatementImpl.qll a0e6669542d7cd3eaa492e81c2383596602c04e56c3ec6c8859bad95b0f779bc d6103ab0c26c38e41c5e20aa62bf47f7920066e9f63ab3e4a8eed415e260587f +lib/codeql/xpp/elements/internal/LocatableImpl.qll b14569c921ef7b3bde7a1facaf7a9146b4865e23a6f226f3e1888f3b2a95ce45 60bd0c6538d6be13d83f477509da09dafb61ff8fe7415364b709b66e1a4ef627 +lib/codeql/xpp/elements/internal/LocationConstructor.qll 4471a0b3c7e30dc81cb31cb7ad3b121d4517c7c3cf49ce9639d957e4d6bb8036 3ac74f98ede3e210de599121b7a188c0c9997b1de4cf3fdeb7179911638805ea +lib/codeql/xpp/elements/internal/LocationImpl.qll fd80fa154077f6746d144e81f3ce41bfffc347e9b4fb875d9e9d51b396307618 5a30a92a51766641d6b2f49679bb983c113d119581700064ee09cf3424a1a0d1 +lib/codeql/xpp/elements/internal/MaxAggregateSelectionConstructor.qll f775d3e62cec3fa69b9b48ea1e86aee07dbdd27722f417e6529a95cea1814791 3e3155067ed14812fca67b22fce57c146bf2a2cb959b25207d43ba42af63baa6 +lib/codeql/xpp/elements/internal/MaxAggregateSelectionImpl.qll d7c23530a8185fae474a37337d5b49dce14504fe4bd76faafd53c9ddca63f480 a740e99d50d78fd036f8854cecf083c0ce156475cc7aa60846b12115873de81c +lib/codeql/xpp/elements/internal/MethodConstructor.qll 5ba24d6d9fafe6cbcb97983d0fa1c09aff2bba2b270e75366cf7fe4e0dc5dd80 81ea7595f30301a29db0ef5eea6f7702083c4ec62644e566ed0d7cf90479c64d +lib/codeql/xpp/elements/internal/MethodImpl.qll 24be78b75b7656eeb4e50ef02d9f902bff0d278fb07d6be8f4e593070cbb7e2b ec7d0f2c6ffe228020e1c24fe69712a3368c972d7dec8e4d52e87e8d1488cf8e +lib/codeql/xpp/elements/internal/MethodOrDelegateImpl.qll b5d553117238479311cb3d6cb121a93fbb8abee2423936d2cd6bbdacb48f5bd6 e599422c8b20f0b7b4e3c4f724c13731f1ea5249f8c4d350bdbaf56db2a6b713 +lib/codeql/xpp/elements/internal/MinAggregateSelectionConstructor.qll e2a1c7c9c62d6a5bacd59971886c53860fa22936d61362ff30155d8f30640cf8 efb04102d03895dcc3ec658868d92eddb0478e69fa34589c866d14cc17e10103 +lib/codeql/xpp/elements/internal/MinAggregateSelectionImpl.qll c2036f33cf5264ed67686eaac1d0b828efd1f5f906d34c28a6ae6ad0c4148094 0d856f9b7b16232c5e2259aaa1272b5e8a4f556c3d1857118a429e4314778975 +lib/codeql/xpp/elements/internal/ModExpressionConstructor.qll 63dba60a69990cf9bc9396cd3f49fb390a4d20cc0898ec47caefe91acfe4b710 7aadad1a2b8f928e0624247a0ca621e35a0d37fbdaff3d81c5e17003c0154c5e +lib/codeql/xpp/elements/internal/ModExpressionImpl.qll 3c6302b795ace4b1af32a0c54fa2d0e24b606b509b8ec67897bdf0e5cbd52610 af6b3ce0d7563a60f9cf9a8ebbe51c346e18c1ade5e93c3d14b238ad244f8158 +lib/codeql/xpp/elements/internal/ModelElementImpl.qll e40753c54805d4e1f7f5c55b566c509f29f40bc7b65c92077b0606517e1922b4 e1648478ae8ab3f56c4605c4c3b1cf187cea6bfd5b154d19d3cfe209d2a87ed5 +lib/codeql/xpp/elements/internal/ModelElementUsingEntryConstructor.qll d73e785a841064ae3a4f18cd2349c53dde15d72e6c4aab7c9432d4f87125af1d fe9336118516a3a28c65ea57f6ff56543651106c7e3702b820706f091d86a0b6 +lib/codeql/xpp/elements/internal/ModelElementUsingEntryImpl.qll c3f1b2cd2a7652abe09e997bdd33b3716b478980e7a75ac0582e722dae14bf3c b5b9883d6f53f8a22e226fa2097324c0043fcb2ddfa7b1586921397dc6cab09a +lib/codeql/xpp/elements/internal/ModifierConstructor.qll 87b8f6fc1c9155c2926613faa416e29e3ae892dd0cb37cf924206c56282b70ca a26c93c64fd9ebf9e0803ac1279af4266f97dbc0696c8bc9b60fe95e3c6766c1 +lib/codeql/xpp/elements/internal/ModifierImpl.qll 1762253ac39ab2d98093d634063bdc907c50867f0e6b4011454060d8a5639738 b4d8667bd98322c9331492103f59cd923d2035af9be0776365a828fe6682e65d +lib/codeql/xpp/elements/internal/MoveCursorStatementConstructor.qll aaff66171dbb94589ec09c00e324a705270b2d8de0738c0581fdd654f55049ef b45213fdac07b82e04befc8cd8ec481b84db9968380f37e2a1914f4e95fa2dba +lib/codeql/xpp/elements/internal/MoveCursorStatementImpl.qll a995b8a766b56aa870d0001b9b277d2eaba401281872cab83a486fab87ebcf22 fbc2e16e122f99ad1ad1b78dd0a552fab90fbece31d33e68b9432875fe0c7c08 +lib/codeql/xpp/elements/internal/MultiplyExpressionConstructor.qll 72b62a380dc00a55a8c11fd80a13d03a0656cd486cea65e53db5d8338f5ab7c8 3930ed7f78dfc140689974569a21bbae0f6d47ea2b995a449d31d9bd825badd9 +lib/codeql/xpp/elements/internal/MultiplyExpressionImpl.qll 89ccf711417a3ed3f6481508b28b1560549a59907b0d4a514414d257a1411fee 8e36b4e4746a5e597884571f300b5acbb5a50894079f65df8e5d189137289e8f +lib/codeql/xpp/elements/internal/NamedFieldReferenceConstructor.qll 437b076ced8313cdea54f802dd993307bc4bc8f57e481f6ca61a7e658e4d6790 f1bcfc497505b132994f2aa080d4569edc331f688c9a1081a151c51c8c6ad5e8 +lib/codeql/xpp/elements/internal/NamedFieldReferenceImpl.qll 58dd42e0beb3bb2fea62a975bf4da9ba7d86de049fdbe6cb6b10cddafd7e54b7 be872e0bb10531c10ff11ac71a5714a579d2e3af01492ecf16570e3e9963d3b6 +lib/codeql/xpp/elements/internal/NamedTypeImpl.qll 0a2e0b9b4a8642d7a7fbddcd2af689778f1651b43758d0505e9b22551a5b5e3f a2f413a32aa71a8b095249619612f57409936eb914dc8b836df5732eaf17f157 +lib/codeql/xpp/elements/internal/NamedTypeInternalConstructor.qll 2d50e9ef9988e74de7d79aa335bdecb9fef979cd23c55c94999c79d96388ac52 b7a63a6651101dcf856f3714407b7820502a6db0353ba55ce6bd92052f83cb02 +lib/codeql/xpp/elements/internal/NamedTypeInternalImpl.qll d155b1437b59255ee38441cc313cd2c17421b272a91180304add4fea03cff681 e6eba11d185a623d1a060f92e83476f23c1e1adb0ac2742d220bd2326744d8da +lib/codeql/xpp/elements/internal/NewCallConstructor.qll be6e792c00aa693f6d439c046f9393354e5697071207cd90cf01859b418d0fac 7026561cf3571eac693cac234c29b1e6d0b0b3e4534885c36508def0e1bb3542 +lib/codeql/xpp/elements/internal/NewCallImpl.qll 4e9d15b37918a365d916a56e2f8913c812a4edb08793bef7952ff5679a5dfa03 4f1112ac45bd3bca69a751aa53d8289dc2c682a87f46c9d3c10fc74274df2ad2 +lib/codeql/xpp/elements/internal/NewClrArrayExpressionConstructor.qll 3e11855315a300fa6876669e1a167541c5451015a0abc280d5db0e5c78c9223d e1461e7965d1ccd407fc96b00bcdbf7b5eb87dd23a0b9494193b17ea27faf7c9 +lib/codeql/xpp/elements/internal/NewClrArrayExpressionImpl.qll eea4ab67b33adf3bb19094216d62f27cfc79de9d8c1d06b7863b83bf419aff1a f1ce4418a491b39b5bdb531fdd5cc9721326654a01ce9fbba4b459304e5ce6c9 +lib/codeql/xpp/elements/internal/NewClrCallConstructor.qll 0ced047f9dbb182c96a33c81fb7beb5b5d4c76dac979a62700a7f47cd59a3c80 7c5c7eedc546107b55bcd739bc592ec575dadc0587377c008ba5b0626db49c79 +lib/codeql/xpp/elements/internal/NewClrCallImpl.qll b5ccaf548f10570763a728086847cae371b97ed33b7dcc7eff5c2b3e3f84ad63 c2bbc3d951df04076cc36364b72f381b2512d7e130167da6f91f9ba801f19549 +lib/codeql/xpp/elements/internal/NextExpressionConstructor.qll 62673a3c869ff014187c79ce68bc35dc3924d8d3ab12306ff00861714c6c4cff 58c21b3d79dd3f0eb9a0c0efd44f244c21ea7f1091d5014e7799fefcbfb57b93 +lib/codeql/xpp/elements/internal/NextExpressionImpl.qll f6fff339860d037281e3a02f2d6ff8cad82ff7bf65f2ebfc267d6c314938aedc 6b461e56ab5a8e55d4c95252c14a5ce3609286eedd4f0caffca52d833ef6de69 +lib/codeql/xpp/elements/internal/NotEqualExpressionConstructor.qll 21d76d0edf1b6fa37732f79215679f8b716dad8e2950847ff897043d53cc9493 6d605c4a1775c11727f43e0648d528b24c171096024865eefc5bc34dc87b485a +lib/codeql/xpp/elements/internal/NotEqualExpressionImpl.qll 98948451df2a7c603332289d50987989e47ad9ebb2250ccfc2b80ba77674af93 19ee6bc5b58365b7daafa162df62f3ffbf668af637402268e35e93c36e6290aa +lib/codeql/xpp/elements/internal/NotExpressionConstructor.qll 269c460095f8ab3a0a466146a13a85860038bc7c718521e002cf85181cf985c1 d02e213ef0679324396f775aff7640fff89b41452a3d1802407764d1567bcea6 +lib/codeql/xpp/elements/internal/NotExpressionImpl.qll 7cecbfe69facd9fcce26328eef0afd0cb68f2868fb8c0b9acaea8b508409ba19 6aceb19424b869e7befc562f035dfeb4d1aa5dc1187b70d76016e100cc34abd0 +lib/codeql/xpp/elements/internal/NullLiteralExpressionConstructor.qll 1feed575867c926da608a0c0c96456f45873ce11adeebcee53b8446785333338 aa921b612254d588fa2d5c7b65f69d57d62f0403099e678b5ba97ae907c40ce0 +lib/codeql/xpp/elements/internal/NullLiteralExpressionImpl.qll d3f99118200bc21eaaa88ef29e3f82da4dedb3ce885a16e2132a74842defca49 129b898e5110ba60461dd86277851ce798bf5bf43709872c9c88caf066985942 +lib/codeql/xpp/elements/internal/NumberedFieldReferenceConstructor.qll c7339cecdeaa5ef8e57ce2347980e181dba0d2410cbccdcf3f1724d885ee9d88 c3ddbaf845a69071e388d9be1dce2a7f90bcb74c73b92f45bbb0a84943131057 +lib/codeql/xpp/elements/internal/NumberedFieldReferenceImpl.qll 642fa0bf437942dc007ad319b156c6fc7eaffc8c5b0a76a2a84afb56ca33d8f5 f9410d3f35d5a91caf5ca8c77ee44a8143f53f480b88a3414f8cbc1bcfe6723b +lib/codeql/xpp/elements/internal/OrExpressionConstructor.qll 7fb8500b25542a8f4c63b539e4b8c7d28039260ebd9645f36d1902bf2d4a17d0 cca045731ceff1050e492f2c913718f51e776f839dd453a5bd7718c4a290c4c7 +lib/codeql/xpp/elements/internal/OrExpressionImpl.qll f2ac3178a9f52c6b9402260be1ff19791e91356f1e09a272b2bee031580709ad f49990c97b1d8d1904a9c95fda6033c087624a3bb445c89e1f14b94a792ad62b +lib/codeql/xpp/elements/internal/OrderElementImpl.qll 848ace0948285a135afc5fbc89b5c1e4316eaa947cea92404be6a09d28c1a65a 9866b33411488ed1d5dea10688bae7e17513f5ad213594db7df5f665dce2d2e9 +lib/codeql/xpp/elements/internal/ParameterDeclarationConstructor.qll 5f12411f458e1b30d7c2685ee2cc4f59fbd4bed5c8ee2c340e66172b266b9f27 994b8548ddf892242aec5903dc57e30e8f9534a94d86838167392b4a7abef1d7 +lib/codeql/xpp/elements/internal/ParameterDeclarationImpl.qll 47b14b8395a7a5748d997038d05ecb3bcb6a6df228a0d48382a4abd5ab4bae94 9f6c91b6a3b0cb706a3b4a22768f516a41e1c7defc0c368b9ed9813fe86d8300 +lib/codeql/xpp/elements/internal/PhysicalAndExpressionConstructor.qll ea4615c0ec45a4c8ef6dfe05a149c6daa3f4494d651cdb18e963b6cb320b673a d4dfa6c0c4de6c03cb9e29e09348b9b1fe8a8dd13da17cbcd78410dd2610e2b8 +lib/codeql/xpp/elements/internal/PhysicalAndExpressionImpl.qll a478caec0ef97d330a134119fd2d0cc9cd538d056715d69e2a512857f6edd338 46c4c1c11569cd191065268d890c0e65f1e248584ecd64569e816e60ac4009e3 +lib/codeql/xpp/elements/internal/PhysicalNotExpressionConstructor.qll 4a8fa4b79fc275e49932d5f3838d14834617cfbcaa8e28e3328a08dab07ed630 c0872c81858a702bef166a476419a64727aeebf48cc8043ce1bcc19ad533e060 +lib/codeql/xpp/elements/internal/PhysicalNotExpressionImpl.qll fe03c369eb346b1c10ee4c5a6b7b57370d070d8c431bb059786133921c5aefee 98bf63b49cb4a7562eb3268e0107296a388075d9d3f06485cb8c795492722e67 +lib/codeql/xpp/elements/internal/PhysicalOrExpressionConstructor.qll 92807986e9d54d74f06ed255fa66b0665e235117951060bf83227e993f526e38 b3033d8ac370a34345e878ce0d834b0af9d55d4e1c34918e255809f017e0ac45 +lib/codeql/xpp/elements/internal/PhysicalOrExpressionImpl.qll 378d23ac554a0e6c1f04e776bf9ddfcdfcc3187412489d22fe0437340366635f dafbfd3101e3e3d2f5a61661d27373147d3cce0c4a3528f43afeeaca6cd28409 +lib/codeql/xpp/elements/internal/PhysicalXorExpressionConstructor.qll e2071571033b57861a27b1b69d831b07ca98dd886681b1327994dd1e53f05eac c491d7dfbb06ba7c6eb56db002fb841170703dfb140a3bbca05d34d70c7196f1 +lib/codeql/xpp/elements/internal/PhysicalXorExpressionImpl.qll 0ee4db59348f06bd2d470e09b5556f5a559bed266bac5d0c3dfb7c67be93e9d0 a7b7433771024bd644708df65c52d2850570b20a80fa117542402787e53defe7 +lib/codeql/xpp/elements/internal/PlaceholderConstructor.qll 56dab50931c03631671b8caa9f5f6d28d3e131a14d7869d251dbca48d4834d96 87ab0147f6664e0a6e49799dcc806a6075d9ea871d209fee41ac4f43fc4a6e16 +lib/codeql/xpp/elements/internal/PlaceholderImpl.qll 3dda7012e796df85c28698527eaa3b889257c49b3b1890f0086f3036a15608b2 6ad2137a117e55432f1538c125e7c82866c660e39de533d4bb7192a675433a7a +lib/codeql/xpp/elements/internal/PrintStatementConstructor.qll edb387dc3e27ad72e35128833ea35dd040a18cd0bb68bff5555a9ed9188d7852 8c5f7a8b7a9e28b73da2988953f140e138d7e19dd85dadcbcbcb608908ab37d9 +lib/codeql/xpp/elements/internal/PrintStatementImpl.qll e3c744149783c5f91bab23e420bc8d238842f24174e4c892a6164a626d1ed5c3 7133ba6c2d8560e9ee994a333145ea4b1668d4ba9d56346eb49f30cca40b123e +lib/codeql/xpp/elements/internal/ProvidedTypeConstructor.qll e47fd349af9a9e1a9506c9d7d2dc97c93bc7569e908649a74a9521c5dafef2c8 743eb7e0d05a75943d5cca1f9004ed9e7000b08d360685ae82b868d284aa5aff +lib/codeql/xpp/elements/internal/ProvidedTypeImpl.qll 290b20998b29aa6bcd87906ab41a0b42bbca859bd9ef02b3ff38a7411332f625 c6d07fd13ceed29bbadaf853549275e04d7e923162ff3b2f4561bbf95f46e8ea +lib/codeql/xpp/elements/internal/ProvidedTypeStaticCallConstructor.qll 6518c618cf98a26b491a87aa2852c95938064b7804975df47a621fd7f3d3584e ce5105373ae6e57ee7f11ffbf3a3a9c5b77d54080058f1734495addbe2fac558 +lib/codeql/xpp/elements/internal/ProvidedTypeStaticCallImpl.qll 6c76d21fcdb389ecc32977e9c803d35eacb31f93c401ec08bfa11b34ea9afebc eb74bfeef09041abacb6c1a0ae54043207302475eedeff96e87572be0460f2f0 +lib/codeql/xpp/elements/internal/QualifiedCallConstructor.qll 977fb04a4677a2880147065181951978f45115017f690758620e6ea74e0bb500 95168b7d4e75ae1d4ef568c49728a8f65d61a3bff8004ec95a799d7cd0b44c91 +lib/codeql/xpp/elements/internal/QualifiedCallImpl.qll a7f70122bdc9ace08bd16bb1684441a441a6152bafc1a18c272c964c437b1ff1 e1bbd1ff0d5fe978eaa24108b23c73da0835ad925884a7f8c05cc395fb3ae2bb +lib/codeql/xpp/elements/internal/QualifiedFieldConstructor.qll fc46462c0ae249922413cbb3549ff65914ebc1f735b6357feb8713d81bb85bd1 5c7d153c17d108d4906b4fcf44eddd58af3b4d60bb2644987ecad4bf229bcbde +lib/codeql/xpp/elements/internal/QualifiedFieldImpl.qll d18459bf2985e5d38bbe9442eea55417076459ced1e91970c8cbebb43c288776 3ce3b1fb9536355668d2b99baaf4ddcf8c6c5bcd6106f7716b629f82b4f5cc06 +lib/codeql/xpp/elements/internal/QualifiedInstanceNameConstructor.qll 5be228aa63fb21306b0c5ddd4e01df0401125c1a69958afda305a3b0e78be8f5 931b40071e6e2c3e30e5a410500fd75585c0a00e1df4e9300152e74c2ab4a252 +lib/codeql/xpp/elements/internal/QualifiedInstanceNameImpl.qll 2b15cf4090820f86691f22eac0e69524322d4c68fd074c5f5b20d037b3f3432e e03c6562914d9cb5946d1ccf4bf9b92d00ab6379a926c5faa53d9b8851a317c9 +lib/codeql/xpp/elements/internal/QualifiedNumberedFieldConstructor.qll 98129e3e6dd1b0edc3ec0597f1ff535b1ea97af1a65ebd2ba2eab5b35f52e679 96d860b5401e528431ad8d38a2ff553b3fba860bb2c905461527377035a73315 +lib/codeql/xpp/elements/internal/QualifiedNumberedFieldImpl.qll 86b555703309dd184f57348a2727382fcffbf7f7ff8d5807004bd3d7d4b720a6 5202d82f446ed784a6aa4afc9bac4a50b71ec184b28782d3113de91d132d2c9b +lib/codeql/xpp/elements/internal/QualifiedStaticCallConstructor.qll 77949619c584a38beb0e6615b435dc1aeb32e877c2f961367c9014a08886a1be 75322d2fa08294a8cfb25538d3138cfd40576196c575123fb54e16f5726fe75d +lib/codeql/xpp/elements/internal/QualifiedStaticCallImpl.qll 3cdd5cff4648922e90f42e9a0ea2fd52e5872c582b8a1ec26a36549245d25243 b93300ece639eb78a98ddeb54e87e1d8261146e3f2b684bad814f8a5ae68a776 +lib/codeql/xpp/elements/internal/QualifiedStaticFieldConstructor.qll dbb341a515f1131e39360dd541ce895f676a00a2cc8d561d69c20be99bdf6ade 86ba0f830c16119d67fc65e2aa747f5c984a2232fdfd3bbf8e708737dbbcd8a0 +lib/codeql/xpp/elements/internal/QualifiedStaticFieldExpressionConstructor.qll 82eebe495cfa58af292eff2dc00e8ca21e479e47e61efc73fb54f7c85fe4063a d2ee1f60873aaed82749f25cff2b34aed1eb14a456d8023558bfc5205e82e2b7 +lib/codeql/xpp/elements/internal/QualifiedStaticFieldExpressionImpl.qll 3afc38a83f92f240b16a917e14d47973d9cf874bc6a273e333178ef523e77b9c b7e70e97b3ff0a60415eacbbd95b66bd0df751063164d48f10a792ebf33baa01 +lib/codeql/xpp/elements/internal/QualifiedStaticFieldImpl.qll 5417fdea3a71b7769339e82090747bfa577e28768947024bb583935a9a86ec8e d0e42d4bdb70f67b391873c603db64220b3577c242379b11170fe9d48dd468b9 +lib/codeql/xpp/elements/internal/QualifierImpl.qll b8accad992af46bd0ee59ff4a826938db17dcbfa506e91e1537d53a661b41c99 a371add9f59c75792137d1b3a9505c675d1da9eff4b4a2e5ef44a01a91b4f1a5 +lib/codeql/xpp/elements/internal/QueryConstructor.qll f9d9aef390b015a0b7394f9aa5fffe06bd42b7debeb8f52ed4d3555abe828004 de0fe9044d8e9e1cfd73917f4cf71fd32f416b5ddc2c2eedf0db348318513a24 +lib/codeql/xpp/elements/internal/QueryDataSourceConstructor.qll 72bb8a68fd975f0670dd7daecbd5b7f14b4d975242fbb762b235efce89a0297c e6cda34098b4fa154d8f078c23784a360d934f00307b31f9e4440e1df95bd723 +lib/codeql/xpp/elements/internal/QueryDataSourceHavingConstructor.qll ef4cecb67be57caca4d4da2d6024284c774a9c3246e94ecfb932063e3e1a6448 d3ff80990f41857df7b9504d44d6e61cbcabc3eadb66db575dfe0e5d9485eecf +lib/codeql/xpp/elements/internal/QueryDataSourceHavingImpl.qll 5ac455658f9add2ad0b16fbc81f5ba94b0db70d236103d14e884b2c42cd9e9cc d7fdd863f28dac2c4edb47c6d7383f54522ad19111ef5ac21c31e778a918c2c9 +lib/codeql/xpp/elements/internal/QueryDataSourceImpl.qll 8c36ade27e9497020020f58754b04db54994a42ab96e319f3e36b5895227be5e 0a5a9327907bb3eb26fc6e5273efaaded592f0572638598a2ed4c34aeb26414e +lib/codeql/xpp/elements/internal/QueryDataSourceRangeConstructor.qll 14e079188422f0ab3564e8521d6d57f202385bf7364d0305c55f0fb884cf7284 acbffd59ae34d46d564932c47d76680ede410204085026ef2560719a4eb91048 +lib/codeql/xpp/elements/internal/QueryDataSourceRangeImpl.qll 839824ac4e7925d7fe124d8962b63a7e987432e7f1a9f4ef9c292f15491ea4e8 dd7e1c7fb8c8c0d409826646ddb91a2282fc1363fc1ecdf1ee3a9f2156aab1a5 +lib/codeql/xpp/elements/internal/QueryDataSourceRelationConstructor.qll caa3cf0314e8587cb2fd2242a5fd2cbe90b0f0820f0bf500ec0126bfb2b4a51f 193456a08205b13e2adedcdf8b729e2ef2a6af68db9da6b10bf429efdeabcb50 +lib/codeql/xpp/elements/internal/QueryDataSourceRelationImpl.qll 21208c08dcd5fd6052b0a39bf9d364cb2f88325fee9bcf928a8a1b6feff61178 03483fc7134657fc09a648a665bebc172d8378826bb4bcd703a76c146e969dd6 +lib/codeql/xpp/elements/internal/QueryImpl.qll ffd2e084611714edfbbf999c9e4efe0995d81ee0ee103ba556765dfcdc1b377d adf73ed9739e3c8879bfec7e50ffaa9fae69613c9ee992510cec334c086c68d3 +lib/codeql/xpp/elements/internal/QueryModelElementConstructor.qll abe7bdcff798ed8ce6df4114065f13700e23bfe954aea399d0c457a4b0b798bc 4da40f4a85709c53c27e89c273e6c8a252c63191626216a88cf7c15ca62967a3 +lib/codeql/xpp/elements/internal/QueryModelElementImpl.qll 4f8c6d49bc17048867c455f166cf2ca0b065b450f93aa5d859bda623297e34dc 00c2bb55d67722183bfe604fb9f20eceade69f59adc5c0c48c2a655146ec5b73 +lib/codeql/xpp/elements/internal/RealLiteralExpressionConstructor.qll b8af7e09e7f6c235ba11440f4489af733ab99fe14a1abdb315d49e5fc1d0407f 5fcaf1ee413385b06632f5b036f8e6b60fe6bd62e30177900a52fc3a14fb3d12 +lib/codeql/xpp/elements/internal/RealLiteralExpressionImpl.qll 49f5deeb663211412d3cf7030fac9a8c99f3bf7c2e3cfa8694fc5f883b18aabf 9b66c403d9e54f9effc534127fd3ee59882e911a83a2435780274ee536f91066 +lib/codeql/xpp/elements/internal/RelationalExpressionImpl.qll 880bc965670a9a07a380a277ae1eef98d944bd567d1dab19d8efb68ce9db0a90 43d62b85de57414fab6dd3ec3090f55f8af3dd7d78c1548661cbf3b934c2111a +lib/codeql/xpp/elements/internal/RetryStatementConstructor.qll ea5dfea4cf0b03e5b71ddd0dd1b05727c66819a8c73a81752e283408969590e3 219fbd07617f44b07dd895b1cd017af1817700195e093676e719d9afe1dcea4c +lib/codeql/xpp/elements/internal/RetryStatementImpl.qll d631bfc487e587bdaceca76b2bbe0f72481267ab287aec66cc7c29a6b61af03c eb3a786edc2efb029f68a929d254c95f7e8c2179e38d281fa9b464deae77c405 +lib/codeql/xpp/elements/internal/ReturnStatementConstructor.qll a15179a4ef6e8abe17a503ae88d2b0cd9831ae848dc1dd5a7a71cc193a39f912 fcf6ed1db173611c7e0b04c547c152694eb0475cc6944c002af85d1f886b3baa +lib/codeql/xpp/elements/internal/ReturnStatementImpl.qll 04010c889dfefa84f1b4f22c77cdc32365ead7d67054e0c32c0e7874ad86e1f8 27809489adaca47c4b710391c69afa9b0214ac9b10cbd45421a0baf532a3b476 +lib/codeql/xpp/elements/internal/SearchStatementConstructor.qll 2537b8f43fee8c8e8853503141dd60808ad21760f630fa7c7fbde4da2afde828 8b3fa94f285ceff3a5ff7ec2bdcefcd923bb2a6ca64b25d04042ec11b568ecab +lib/codeql/xpp/elements/internal/SearchStatementImpl.qll 2308611b7d4ccae07abc0e732b709f0a72610cdff49d8cc0ade8caa04ef7b879 7b70a5c621f29e7c33f967c886ecbfbbbf3580834385be29297c4eef36eb2d70 +lib/codeql/xpp/elements/internal/SelectionFieldImpl.qll 12975f4daba9b7a90eab24334b2a8ab725a3cf093f706b04006ad83995306386 fecdbdf736d1670e0f7cf23985e56891a62e6b4e8c9ea996d42f0533199ce870 +lib/codeql/xpp/elements/internal/SelectionImpl.qll cd61d68fb42935ecbe7a078787403cd0b8947903f28957b777eb424442b583ec c7e183dc42ffa5f87c8995c43a278272354a96782422e0007e6873809c44a839 +lib/codeql/xpp/elements/internal/ShiftLeftExpressionConstructor.qll 5e68aee4eac2f68b4b52309b7e591063e0bd58a54bf3766ca1155cea19fb591f 3c037fa80e868396e617eea1a6441d03ec026d309ebc6ea31e5a4f358fb842c5 +lib/codeql/xpp/elements/internal/ShiftLeftExpressionImpl.qll dced74eedc99e998db24bdcde9718eaf42cd2feb988a10098356c3db8faebf10 e9d3b4235f7a7d744d17e3d03656619f1325e22e717638fffc162703677349fe +lib/codeql/xpp/elements/internal/ShiftRightExpressionConstructor.qll b2e2c5b6b2a00d617b9f7711d7ba3793dee1013a1b777acdc4bc1c82f5f66f76 013bb630061b138820602c0078e21a0d808a22719d867f60156f8d3eaef69f49 +lib/codeql/xpp/elements/internal/ShiftRightExpressionImpl.qll 329a71e903c1305167709a0b194ece086b0b0c384c6b923f08e660c94e289187 d53fd9888a868830eeaf98ff4c51ec135350f800f6c77b586b4f51995968b02e +lib/codeql/xpp/elements/internal/SimpleFieldConstructor.qll ea90cdfeb94c8ae6ea78fb6977d5797e2904149084ebdfdbf67aac7dcce1482a f148432b727ca1dd5772438945a266d4499da894cafd959a2ecb3d997b1e09c7 +lib/codeql/xpp/elements/internal/SimpleFieldImpl.qll fdbd0ddb31ece490cc60df6b7e99ebfa0e2953972d599fee047dcb707c5ff505 90ac2a14aff0bcf568422fe66ee4c8c89e769c5c861916c67e4f1920abcdf4e2 +lib/codeql/xpp/elements/internal/SimpleInstanceNameConstructor.qll 3ae55c95b0820f89812dae308c608640628dcd6dc670ec06978070490c665412 c539d3c96875d60deb1c76b330753c9ac62ca3bad0f1d2d776d9d9d79137a513 +lib/codeql/xpp/elements/internal/SimpleInstanceNameImpl.qll c7deb5f7aae311cfd4e2e76c1c5f5c50ec1f8b7a407e85c3ebfa40543aa6ed69 e9bd873f35dedc19ece9358b959be360315411b8a6fd81aa489bc47dbed7d1b8 +lib/codeql/xpp/elements/internal/SimpleOrderElementConstructor.qll 31535392a1a98cd877809989dfaf350746be6946b6f20d6975d4e5945cb80c26 de134d9520fb40878f6a6bf61d686b5ff5b20797b60747b84b3b6fc9a5a80dcc +lib/codeql/xpp/elements/internal/SimpleOrderElementImpl.qll 095f30f65dff4630d0f507397be234420071ac9d3bf8f800f71afa26a4d8bde3 08b1fac5fcdfce570ba2c3781cd1f526f09145562bb922f5967a63643257152b +lib/codeql/xpp/elements/internal/SimpleQualifierImpl.qll ca4f8009475bce3a0fa80105bbfa434989357ecbd5564b63b1c95d44188cec10 23f4db732fedbbe602a50f12755c55f692f3767dfa58b99c171dd95ded4d5604 +lib/codeql/xpp/elements/internal/SimpleQualifierInternalConstructor.qll 8d9ad37c0d55c205e49dddf944efa973d99a8620e368e78970ea53cc7b5d3c4b 9170ee4404c5a569eef7779466d3919d0837a95a9d224dbf4d5dd84b9dba86f1 +lib/codeql/xpp/elements/internal/SimpleQualifierInternalImpl.qll ed43e1c7f4509ff3cc03705a8c5ada7561c92ba1c18ea53369eedd0673e3da88 d3ab133c20549fff327b06591e42e0a1b8f3515b27c33291f45dfb6b678db167 +lib/codeql/xpp/elements/internal/StatementImpl.qll 84b8b116ea0baab406f4dc7339c79894529f3ec962ce2b29452d9dabdc9ad718 8f09b40b9df5b612cbf65bfc9cd948216a5404e12b203e8fefa14ace72baa801 +lib/codeql/xpp/elements/internal/StaticFieldConstructor.qll 110912387bedef68516ccc23ea0b0f0e519a9d97158efdf9b62ec70623db3edd 4a1fd2a4f84c80210c4041ea9973be83f023285516ba5af28159924a7580b5a2 +lib/codeql/xpp/elements/internal/StaticFieldImpl.qll 6ba4de2839a7c6a093dc507375faeddf6d635afd44de4cab6054e99904b858ef 023779dadbea77f1cf1ce782d33f8415376b5e8f9c2f32de6af14ca367610eb8 +lib/codeql/xpp/elements/internal/StaticMethodCallConstructor.qll fe0185e2855ed0df5544b6b5248d2e0116018d538409d494633c876693762450 eb25fad2c2f259db16263fd146a37b90c60866fdbd7f18671bc9a17c6d4410d6 +lib/codeql/xpp/elements/internal/StaticMethodCallImpl.qll 096ff52c81f72dba645052cf0e3eea51afeb0c2195d8aae43c32fa534897fdef d94dfaa8c07968c0772f985efd6f64a7758d3e8618df4ef8029fb64cc5c65fb7 +lib/codeql/xpp/elements/internal/StaticQualifierConstructor.qll 9996be4c1dddaaa9e5b757419ef2f4a9fad94e853277753ec2ceaad77f772b0b 9bfb31b7b33f502b450934b7a1d568b7b4f501a46218816bbff863bfb99a7257 +lib/codeql/xpp/elements/internal/StaticQualifierImpl.qll 791d907a36a79aefbc93146a6c85bc4c53397bfd0451e765ffe2ce5d3b17a69f 0a92b973be89c3e4af27295f347d465162460cc56cfeaeb6379c4def996caae4 +lib/codeql/xpp/elements/internal/StringAttributeLiteralConstructor.qll 8d6919494a458bd91483b5fda67f77f588c6d72937444868af54a3fb4a53a308 9e9baf11b9497e5d4243a127c4e62df17fae8dda59f0c1e7686463ea9a1c1346 +lib/codeql/xpp/elements/internal/StringAttributeLiteralImpl.qll 400a5469c284c4d1c13352b39bf93f89499903a53dfb4b09cfd546ce69b5704b 03da5d4fea1336a315fa1d7fa5317f9d486fc8346901e5492f460f5fe078e44f +lib/codeql/xpp/elements/internal/StringLengthTypeConstructor.qll d42568bac0a119d90603f08461fc970fbe509a4a1312d7340cad2f06e2060ae6 56c45a4502a254f2f2e1243d68ae68c24416889a890b98423328615a0e681c86 +lib/codeql/xpp/elements/internal/StringLengthTypeImpl.qll 78c03ede9cae566301661943625ef60f1921ecd6e87b05bd70b41156b7e255db f933dc5631389b5125f166e670c8cef2c5760673353f478ff82ef213c8b8cdb5 +lib/codeql/xpp/elements/internal/StringLiteralExpressionConstructor.qll e34d40353c5675d02e92001198301a19aacd1de9c79e7b81703baef0f4ec5c87 551210a8174bea341db56995fb7897cd447f38a887880b7e6571e64bf21c3b96 +lib/codeql/xpp/elements/internal/StringLiteralExpressionImpl.qll e9ae2e834cc1504a3db368b434263aae5596edcbbb38aa9cc42c637d2fc112f1 7a1ee311eb61350cd629d5811c1f3bcc1967f361671f46cd1de64910e9ca3730 +lib/codeql/xpp/elements/internal/StringTypeImpl.qll 26e09b74ca80ccccd91f79d58dc466520e4ac6dd8bb6c13b5e26458d2c5677a8 c050cb11f4c230ec073dfed89298e0d43e282f63c52638c8a3a96791459c74d4 +lib/codeql/xpp/elements/internal/StringTypeInternalConstructor.qll b438a68b2fb3ad7f2a47ed55b9982917351bb42d3f285618dc38fb0e8d9a12cf 3d50077687aa0c0e3e48fd49a874ca7a831cddd7d332497d1302002e4a160e43 +lib/codeql/xpp/elements/internal/StringTypeInternalImpl.qll be569196d485e1ebb214f34900f56434f08745dccbd996366710e4c43e871019 5d88a5d6c62c3fb312e9a68379b357dd29f3582212827d848f585aaddb004617 +lib/codeql/xpp/elements/internal/SubtractExpressionConstructor.qll 0b904273d08e5d52b3fecb8a38c778742d2d292faa9c60e6a76803db5443a368 4058e603c6b674784921cbae48b77e0a85c79f8392c4a8ea15129d8e4b4b9ddb +lib/codeql/xpp/elements/internal/SubtractExpressionImpl.qll cc36fa3f2f5700437ba87d465292aafac81d8131355a1e77a9bb62dccde2b0c8 7b58aa61657ff5f008c4de1fde976564d036a04a8d79e1017585781453777dfc +lib/codeql/xpp/elements/internal/SumAggregateSelectionConstructor.qll f6e78c18558a330d2afaca00d195edc41a215159bbf9f4e9ac47283dfd5af417 fe799cb2444f7f27e1038e4f0cc1f4f346b71c7802ce52749a041403c8b97069 +lib/codeql/xpp/elements/internal/SumAggregateSelectionImpl.qll f4493bef88cac162f7a30fde7e61720450e61a3dc52be584661c81756e910c3f 42e34a6afcdc91dd8d6084a812961c6bb3f27868ce738e4e949a596688b8a9ab +lib/codeql/xpp/elements/internal/SuperCallConstructor.qll 1393220cdd7943213d2ebcd72966be7b06536f20dfc2f01f5d75fa4d752cfd09 52927ed2fa0289a92c19c8b2c20d2711fbb1809ab317d8f6aeb649134acf51f1 +lib/codeql/xpp/elements/internal/SuperCallImpl.qll 63899c0cab0968c2ec6f8c086e9e65f2d41914982d1e917d819d637b91456063 2943726415ec68fe3d1913b48773a3403167c0f5e2e22bd40b594356ece798ad +lib/codeql/xpp/elements/internal/SwitchCaseConstructor.qll 5bbba2f3d00a89b700dc056a980674dbe005f598f81be9eb68b29a09d7b7e58a 419b319f282ddafca4515a6d3926e0e08fd21a7cdd23dc4687810e536e0eb17b +lib/codeql/xpp/elements/internal/SwitchCaseImpl.qll 0424cfd8ab7fe14e107b499f8e651ffda3f2e1cbfd8bd810117fad1e0904f0f1 c5fb146b866e388c52f9efbec3a3e97e6a9709d4cd0a99f2b965298b27cd9a6d +lib/codeql/xpp/elements/internal/SwitchStatementCaseEntryConstructor.qll 626fdfd2cc798d3deeb3c03f93e1bb80a62002c990cc8c7fb03784e9cf99f446 5cd2e27afaf0c80e838b6f20d39d9883f671be232655cce8fb33910c2ee4106a +lib/codeql/xpp/elements/internal/SwitchStatementCaseEntryImpl.qll 22f8660f708f871a87b5261f35deb764a77a81d078f2648248dce9ab85b8fafa d5afa5e2076cf47059d07e6886f608f9e77626dc37fa934bbf1f0048dde9488b +lib/codeql/xpp/elements/internal/SwitchStatementConstructor.qll 946ca504c2125981bafc914919e232bd37e9a517028b0b4d626beea6357454eb f500131c5229a7deb4fc29706743c62a009f7f664e4a655beddd24a2e21ac2c4 +lib/codeql/xpp/elements/internal/SwitchStatementImpl.qll 0a2dc47e8281a5d31d903fc4ccaa7228e37a286cbc4c4b63b1641b89e4dafd2c 176a2509a6aacc4e60f57e7762c200bf562fb2b18343a1061fd37dd47264b304 +lib/codeql/xpp/elements/internal/TableConstructor.qll 63c99efed17b17e62493a0f6bf1f4a2ff1c47fe3fc8f0c1e5f2d0727257a4b42 5eae33980f800c5d94eae46e104ae70d3e774680a54bb0ed4aaa613a269d9dc4 +lib/codeql/xpp/elements/internal/TableFieldDeclarationConstructor.qll d429d788401c0322c87e75dc5b09ef2cabfbc73d341c98292c89a73bc50bab28 86a8ca6851a661adbeb65768f78a821b0ca8181b177208bbe6dc2a81890ab8ee +lib/codeql/xpp/elements/internal/TableFieldDeclarationImpl.qll 7198508d4f3531f21cde39333fc5e88289c3c37a5d335e31766d6894f0878314 15f0c7e967c8bca54b0b2b5981576eb138a23d1236a2998263ab6f99444bc9ad +lib/codeql/xpp/elements/internal/TableFieldReferenceImpl.qll 20d3ee31c07a42b59d6de163d163f843d2da349d687a4b53b3ef5f7ebe5b709e cd9be6b8adfd27b3a6dd4fa6e3d6726ca644b7022f6047d1c30fc387913bc14b +lib/codeql/xpp/elements/internal/TableImpl.qll d8b987a8568a8955cf18c7b6d6b626b559b54ebe47abd48fab361e4adf4b3050 af16aff32fb10ace71f88234e4a7836885a9b24ff76189fc7cc752aaf80978c3 +lib/codeql/xpp/elements/internal/TableLookupExpressionConstructor.qll 27e6fc7e1e2d7739404d07f2b14a24a29a11fdb2b1e465c1ea7d75ee3a515bf0 834b222fd519917481c3e3bdfeb81d7e79a7e32c8bacaf8ae4ff9ad4b8857b8e +lib/codeql/xpp/elements/internal/TableLookupExpressionImpl.qll bdeac091c3c8fe752501d8974ab221b4b6a1e40b7d0409cd3bc54d6bebea6fa4 7c869cb991275c3a81fa544c8f3487edd1212b46a64c49fa164f5ab2f503d9ee +lib/codeql/xpp/elements/internal/ThrowStatementConstructor.qll c14d597df19bc283dda780ecf494f71aa5e6aebe686d26d0428feb9ebb9f1be6 68d2b61431767632d6c3326939bb7e35fc02448e1e9fcc6ae619bd71daac3286 +lib/codeql/xpp/elements/internal/ThrowStatementImpl.qll 846e1643dd68f51d52d7c2493c8b6af88fd2cf64109cc139b95d482d8644b015 794e8f816ec1dc55095ed52f3e012e73a268a93bc60a76151cbc44644f7d1198 +lib/codeql/xpp/elements/internal/TryStatementCatchEntryConstructor.qll 50faa0cff457498409c8bca4fce055244de9bb46f7a7afdfe5f06ec0668820fc 0fbe93be4d7ca50357d7ac6e8fc7089a4c15e8afc4bc083cf34e345f65362c77 +lib/codeql/xpp/elements/internal/TryStatementCatchEntryImpl.qll 0797386842fcfc9528a6ca5ec28a1393f92ce03a38d90c940e84fb59500f3fe6 1c17c209e17cffe1d0330aedd6e5deb3f415704407d70afa96a8a1b727be0406 +lib/codeql/xpp/elements/internal/TryStatementConstructor.qll 76fa4d9e6fb14f6b14271da1f6a8e45a3844b20ea9a2d84b40b67f845d6cb761 e039918dfee9253efef550903d5f39ba19712c13f32cc640920be4bb2cbb66c1 +lib/codeql/xpp/elements/internal/TryStatementImpl.qll e6b8ff73af6abeb5f76e3b9ea5b660d286b1c7d01f8bf49b170b5820c82f68f4 99103be58db40a67334ae695808899ba1d0f3b88fff01b6f4393216347bf652b +lib/codeql/xpp/elements/internal/TtsAbortStatementConstructor.qll b26534dfe80e8cd8b5c0cf36cb0df1854cde7b8a4cbb6521639d66dcec212000 83958f1ddeb60079178b1ebed6731969417268870b037cdee72e9c0676a8f0ad +lib/codeql/xpp/elements/internal/TtsAbortStatementImpl.qll 7cd56977d0250a97af976e2a2be43c401492f222fcad2d01ffbc41522fe297bd f86a01be83b26d14d17abf37f2b8030efb4ac894752a67008e85d4006e02f837 +lib/codeql/xpp/elements/internal/TtsBeginStatementConstructor.qll 7b9ffb70408cc518e21ce3cbeb2bfd2096f523a8d3bfa1ce93039fb9294e8ca3 71e312cb7e3610c88ab3e03fd9bb469eaaef5ed3c9295b710ac54e5bb334f891 +lib/codeql/xpp/elements/internal/TtsBeginStatementImpl.qll 5f8beec0233307a0d834a446ac8c662458cc5bf1dd5f74163566cc456d742df5 0ae84415593ac227bfdba72710aa11b6935e07df8e837528323083d6357018bd +lib/codeql/xpp/elements/internal/TtsEndStatementConstructor.qll cef5592a1986b0348ceaa01579d6f5ee4b5e33daca3242cac7ad26140572db66 1550f51218681f554e1be4a0e00e52a0322d5385074c443565dc38ee9f395a43 +lib/codeql/xpp/elements/internal/TtsEndStatementImpl.qll fcb3fe99fdcfdffd8a8052f698bc8acb93f89d2b3edcdb76ab18d96a8ad6dfe7 8349c5880afd088e8a6a7d7baf13e7043e253a7d2072eeb653ff74cb30dc5dd1 +lib/codeql/xpp/elements/internal/TtsStatementImpl.qll 78bf229b0b1d7823ae70fc5edc0d05ead5e2e00ff685e98aff2840282170f9a2 734c69197019191b89230ab13d61f0dfe62b6406f3a843199517d4ce35e898a0 +lib/codeql/xpp/elements/internal/UnaryExpressionImpl.qll 28627e9c33d615012b7ae8169620304596e535bb0ae3bb0ed21e8924380f7f3f 955205a94a1e02c450aae3b2692dfbe6764cf5ca715570564298eae7e425fd35 +lib/codeql/xpp/elements/internal/UnaryMinusExpressionConstructor.qll bd78efa204114474b33716108772e34ebd892d9d2065c7b40fb7e1f975d46859 31d23df721edfde6b07a70c72a089615adfea636544e934833e30fdab095132c +lib/codeql/xpp/elements/internal/UnaryMinusExpressionImpl.qll c75c57832638f22ea4d0430dd5bcaaa1de1e43db21cae3b05815f50e471b3931 0fcd010945cd1cfdbd7700bce63e6d6b27cc118b31da5b7d9c13e2c830bc19a5 +lib/codeql/xpp/elements/internal/UncheckedStatementConstructor.qll 3de25efc203249e2e442733b5986a74c6ea6511bed057a050396b834e5078e03 571b4e470c1550cc653c7620dd7e3dceef06afb90ff5f811ae6e0a822df100b7 +lib/codeql/xpp/elements/internal/UncheckedStatementImpl.qll a6562fc1ebf2958213bec7cfef1bed901f18adfdbacef46ac6b1ee579fd59f11 821ab546efb2c15a3bf7c2da7269cdce7529e55a65e58e2e0c6461b9dc80ddae +lib/codeql/xpp/elements/internal/UnspecifiedElementConstructor.qll 604761d0b427e45ca745abdad39cb7e4904c7c7ae6753593967e437da32978a2 c0bee8c53a9ea60713da34f22842c9a4d2090f1228d7d651ff5d9f4c41d1ac24 +lib/codeql/xpp/elements/internal/UnspecifiedElementImpl.qll 6c065819f61582965f3df28d59d83f541b6903e9009746c91b4a6572ccee8644 4a9ea5abc1553b6d9bf13435869cad787d5f01c7ebaf181efcbd3d184530c765 +lib/codeql/xpp/elements/internal/UpdateStatementConstructor.qll 19310b3ab5898101b2b2339dc900534c380458341dadee428882545fa3310d28 9f32f031790d697e68f36999383b147211348f864f34790adaaf422dd9a5c7ba +lib/codeql/xpp/elements/internal/UpdateStatementImpl.qll d05982217147ba6d7f3853ad702050b0e17dfa80fa9c08efeaa5f9183f2b78ba 7e2f3c1a5b240df130e792518e74d07a743b59c9e4390b344ca7365f1d02ea9f +lib/codeql/xpp/elements/internal/UsingStatementConstructor.qll 20d93cdf5bd2b1b4b7b6b90dea6006a5bfcd4f40d4559b7bedfc4870f5394c4a 6e06fa5ae79db13df7e7179d4b5cbbaa1cea6d3602b5e03ca0484fd80a11afef +lib/codeql/xpp/elements/internal/UsingStatementImpl.qll 0a8798150337273f448e13a36138cd6b0e05729e30857ddedc03f6b8f769c5a1 caa9f522dd9848c9160ca588fc728aac25674c70cb4ac38af12b29bd6f42ee80 +lib/codeql/xpp/elements/internal/ValidTimeStateDateConstructor.qll 7c402c3fdc46301a22450780f594345a58c71966338014e389fc253a62684ba6 0ac97aef4001000f9479e5ab314cba4b5a52c4018faf50292fa5680c205e7369 +lib/codeql/xpp/elements/internal/ValidTimeStateDateImpl.qll 8f17acd7c42276326f4d624d20437129234ab238888b4633114f46e895ffdde9 8035068cb1bea42705562ded70bfac48466bd6164d470b48d7090d371119e2b3 +lib/codeql/xpp/elements/internal/ValidTimeStateImpl.qll 3b6a7a9c86aa3b7c4db09542ae69de0f6040e38cacc110ffda0efd33da971c4f 5ae4a73208bb9886eb6ba129c0130de421aa8b56e56b5c3db160ee96ade9fa3f +lib/codeql/xpp/elements/internal/ValidTimeStateRangeConstructor.qll 1f8245910563d8aae77df17e6ba5dea791e27371dfdbdc8b3a41efd2b50390e2 9944817e69058be2555c643fd37a57914f24c06727f9a857458a322f9a299a99 +lib/codeql/xpp/elements/internal/ValidTimeStateRangeImpl.qll 05cce568bd04d79d779a472f0a1dd4d2f947fda2bdcad2dd429c2df11fae14ad b2a165c43e45d057a9f334da58c3ac2f3a091459873c70ad6e47df2b53e0cc4a +lib/codeql/xpp/elements/internal/VarTypeConstructor.qll 0c5896cba8ccca081cf937cc925153944ce3bdedd27f5807119914fe7bc275ac 018f084bc2cc3211313edf4b542d2fa0937d0d111bf4d939b5870e4b4edfddb1 +lib/codeql/xpp/elements/internal/VarTypeImpl.qll 42a2575d019c30d079693b6ff6e652d619cc858555e8a59270a65fea8ad10214 86446861a6977db6b03ae5457ecddd1e47e951155e790a45be5ea0166a32a7f6 +lib/codeql/xpp/elements/internal/VariableDeclarationImpl.qll 688a7487a65a7f42c892d2068c437a94a8672d8fc83cac0a23cfc900ae966057 3f7867e09d21d1deccc350063046769effacd9b1b9a0d4f57b8244b4aacec64c +lib/codeql/xpp/elements/internal/VariableDeclarationInternalConstructor.qll 35648dad9a2edc3479935dd75277a192aec70625470a3ab4a46cbf4c9e15ae2f 4baef14d347153c0b900475300cf4804e6986a3f1e8a5d7ccacaea6832f8691e +lib/codeql/xpp/elements/internal/VariableDeclarationInternalImpl.qll f2f381b8e5ed23255a5fe659044b8f53218788b39767a64238c97687ec64341b ee4e10dff984dbfbb71f39eb61139fc365a6c22b134efcd80ec7f28ac39e4854 +lib/codeql/xpp/elements/internal/VoidTypeConstructor.qll e9203ca925e5df786952a6b6ec8e875d283c73b832f082028260a716359f7736 31b450927af88c4640cd3d3989965be487c9db739beadab6930e0e1858941ef5 +lib/codeql/xpp/elements/internal/VoidTypeImpl.qll 08283056892b61c79406d1f00f617e58bb5a62bbe0b3e047dcb33c8c34cc6389 d97c293370805e2e3f7e0bafde7f6d5c01f3bf09040159c8c0fe58fbe4c009f5 +lib/codeql/xpp/elements/internal/WhileStatementConstructor.qll f07bd4d968bd5908c2ee2f155f867c9610d0ca58b8c9151a4213dd9c9d390327 d099a0da32f366703e8e9f5d613065a3e01e61d9432cf8382cafd9dcf19af564 +lib/codeql/xpp/elements/internal/WhileStatementImpl.qll c4486dfffec55694711c37b55284baac2621f9562ad22c790e58039067ff0c0f 3ce1f4c204059649f82443653f8a7d1bf9c2f87d378813ca704c7ba3f9f141b6 +lib/codeql/xpp/elements/internal/XppTupleImpl.qll 5c4518a53c38fe3a8c57463527d696946b3652cea1445b62e3280dadcb0d256d 8e70115a28fc980df5d34166b35052ee3216e14fec423c7be02db346c355fd47 +lib/codeql/xpp/elements/internal/XppTypeCompilationUnitConstructor.qll 3afc91614afa6401ed3c4bcb3c3adbab7b408cff3440b2a69e301a13cbbe79a8 524f8af109285e554e5ef02ed4ff89ab3c7c1dc5f336e3afeb1d0fda9b7fcb6c +lib/codeql/xpp/elements/internal/XppTypeCompilationUnitImpl.qll 014b4832293ecf12dcd32ec5961462d92671f87f09ec30b465155944b1f2fd0f 8bcde8e4091433ba09c5efdc81fdccaccc1370ff803f942fa540058c7301f0d9 +lib/codeql/xpp/elements/internal/XppTypeImpl.qll f84c6f8d001047ce34fcb7d14a31e29e9f999f3ca7dfe8e8ab9b71868004b9a7 b51ed1b3b07104e7ad454cb8e78cf40f1a603750da5cdbe572b810a35ecb0aa3 +lib/codeql/xpp/elements/internal/generated/AddExpression.qll 8239f75c3bf8e7628c06f7823474c8ef36a93c9ec2acb76d954a22a3717bcd73 676046f5343a00703edb3811a83fc456f67c75a554f37c2b606a47d15bccbda8 +lib/codeql/xpp/elements/internal/generated/AggregateSelection.qll 1048972d53250fb574a98a51f3b66c9c0a8ed08f6bf277a1b385cdd05004f0fc 2e54a412f215ecab7b38f0f784f511237c1ac93123763ed28263ce853800da67 +lib/codeql/xpp/elements/internal/generated/AllFieldsSelection.qll 0b3ccde867e93d9f410a89f3bb05c06272e4a589630d835f28b4dca0b275645a 0bd2ccf1aeac70fea5439dd65ab243d73436578172c2086f82a36efd68a2bd78 +lib/codeql/xpp/elements/internal/generated/AndExpression.qll a85b1dc72c230f62de5fe8957f259abac2d75a9c30769f573f81f8161e46b4d0 205b5a72e6a7fec576e6de4ef6ccb3d8b58e9a694e5d64cbb2fd36824548bc9e +lib/codeql/xpp/elements/internal/generated/AnyType.qll 8194db8b27cf40928c25ec4c062991adabe4389580b56cd8f3bc85ddb99707c9 2eb76cf5d376cfdea7252254b83c30257b848304d0c1b2580ce32704eb4d7c5c +lib/codeql/xpp/elements/internal/generated/ArraySpecification.qll 42a06eb15418c07edf62715ba466a1ca47b79e427c08bd43a949706d9ba7f8a3 2a85bd089fbd6c1d512942eee5ca5454f682d9ade484afd2d01df1f0aad9ec59 +lib/codeql/xpp/elements/internal/generated/AsClrExpression.qll 77afcf856a03a7266b7132fadea524e1f3a1cd265172cf63f673e7f3d4d95099 ff6d1058bdb9b97e9fd66e015f96c655edb5942223ca0d6ac05b29950f49ff63 +lib/codeql/xpp/elements/internal/generated/AsExpression.qll 244c3d5debce2aba4f019bba8a1c3363431b10e568a2707e9abb6743366f170f 161b3bbc6b0ccbd9d83121cadc42ed9de3ff45018ab4f9b6ff0bc6fb4a023c03 +lib/codeql/xpp/elements/internal/generated/AssignDecrementStatement.qll d64f96a50721a9b14a735f40c15b30d3cd6c9b33f1de8022d31fe633f9825163 c45ef8c4e3b70e2d0dea3cd013eacc0bc0fabbf65c2667affecdfaa3b33f3531 +lib/codeql/xpp/elements/internal/generated/AssignDivideStatement.qll 461cae0f5735a179aa74bbbbadac50c0357a4b392c380b7ee4d2ea7d9131918e 99a9202d0caba40baddb94f6c7237a842b6227e4c7a212d040528391cde0df35 +lib/codeql/xpp/elements/internal/generated/AssignEqualStatement.qll 5b9437cf67b90964b75d0b28dff8de0ae54262fc89323f45ff18826f2be1be4c 7870b04977f1d55192c159473ac57c4941b860009fcf8f4f7d434513d2e20e00 +lib/codeql/xpp/elements/internal/generated/AssignIncrementStatement.qll 2db066ec69ade32f32efa35df143a4c89041de23b68f7fd761b242f1a89aa439 ad2edf28650758c6271ec325f2131da43d94f8a4d668532de27d9412ffdccdee +lib/codeql/xpp/elements/internal/generated/AssignMultipleFieldStatement.qll 03d95115df844b1a655cca5becaf4392e1f36a471a6ccd26fe5b5ad20d9892fa a744d0248692273b8d03880e82d739e867454541894f854f208b3b18aa37d6a7 +lib/codeql/xpp/elements/internal/generated/AssignMultiplyStatement.qll 550c48f24d98b8afc7452aad9e867fec920e783dc5b5c52c83e9a63626d58551 b77410cfd52390b6ffdc9f5d4f9b6ffe7113674810e81dace04f075883dfaff0 +lib/codeql/xpp/elements/internal/generated/AssignPostDecrementStatement.qll 64d38c2b195e13315b6d52e9a2a041ede2533d640ea4ba6bf1178dc1e791e6d3 6fd8c5f48e5b89364f2ec7f2f53f1ca8396fa4f7d5bc38356ddfe4e5362dfd33 +lib/codeql/xpp/elements/internal/generated/AssignPostIncrementStatement.qll 95e1feb52a094a5032c3b5d4ec88a596b845460031cadd066704259af2ca7693 9b4b02c7a9a932c503690b3f49eeff998d1c6408264a1b95fc0b78ca95a8883b +lib/codeql/xpp/elements/internal/generated/AssignPreDecrementStatement.qll fd0095fb5c8ee0fe0480209061aca3741144c112ac1a15a385fcea093bdec876 89bb3236d149e6ac9d8d89cb69cdc87552f4f17283268f1086521ec44c0ddcff +lib/codeql/xpp/elements/internal/generated/AssignPreIncrementStatement.qll 4f4ebed2fe87a092134765457c18b37939ee5714cb968926ce5a3f1e3e7dbad6 7da7febe93143dbedc0fc92782296c6ab140e8a99a8b3c2b5e2a361e0eeafc95 +lib/codeql/xpp/elements/internal/generated/AssignmentBinary.qll 96623d48fd2ff8d269ee350e4e3f94c16f071aa9e1e380d29d6ef2c16dc4e8f7 1aa0a2306bd73597f7f6f39bdf812f1295e8e6176b9acdf73b555ee1f7523daa +lib/codeql/xpp/elements/internal/generated/AssignmentEventHandlerBase.qll 042a525ff72c3300e96de80099c9b84b4163ae8ae636f5588f37588d617faf35 6ff446d8b4d593e737297ac97c64d88f5e6c0fad6b13f681d3426f8b4d588811 +lib/codeql/xpp/elements/internal/generated/AssignmentEventHandlerClr.qll c32e00adadd45c0ea60bd9e27212d67dcd7b0bed93f951ede137d504237be299 ccb2ef3062f658f5c71315192e0970a8233da5aaa150f96d44a4b3b3c2bd67b7 +lib/codeql/xpp/elements/internal/generated/AssignmentEventHandlerInstance.qll b660abbb46c730ad7c4a2132c939681c043fedd20aca8b25b889748bdd2afa72 90aa6189d696f0b00952eaf814114c7dfd23d6f73a016cfe08b44055b643715b +lib/codeql/xpp/elements/internal/generated/AssignmentEventHandlerStatic.qll 8157b3297751a09cf9c873d2a61db3302a82db8fb826cf499fa5f0d3d4cc9a40 c1a22bc38e21d94c12cea7c7bb8b2ddaf8b1df7456c9e5a2be7c4c0ab0242e78 +lib/codeql/xpp/elements/internal/generated/AssignmentEventHandlerStaticInternal.qll 9c94a285c41eb4b2fa10a8b45dfcdf708d3b93de704474d037530cf6644ac6ed 4dbd44c6e06463d280388ecd1680a87fcbedb2a937a928e1d98b98d25b0bb9a1 +lib/codeql/xpp/elements/internal/generated/AssignmentSingleField.qll 20bdca8e40ad0e22ade64945a6bffd0cc1ebd4dd5855bb38f9f2dceab74cf79f 513c0642cbbeae35964b4acf22d6181dd8c21751cb96ae97bd5c14c12bb3f5d3 +lib/codeql/xpp/elements/internal/generated/AssignmentStatement.qll 6b4221595340b68aea7f765f1b36859a30019f89c27260294957925d42d1c664 7db8a7bb2d624efdf685090e69463b922d393707a56b80318106efb286e80f3b +lib/codeql/xpp/elements/internal/generated/Ast.qll a1a7d5b0b458afa22f06916cbd740fdcc6731c4738590a77f04ac2f88ea4b088 c9aa12d6e07d89cb43ef8fdc76adc6f4f87d93a73f331150901bf9bb4bbdebab +lib/codeql/xpp/elements/internal/generated/Attribute.qll 37fdb05d91c1e533af27a0d271a4ba720b4f16c60e158e3b813748f1b1c7ccef 49526b8473ac66ed66b37d7ae1f0d549002ed4c883944ddf6a612eb8db5d994c +lib/codeql/xpp/elements/internal/generated/AttributeExpression.qll b868a1cf9f140e217cc6ec18b2636f43099563769f3d511ec1748883b566a560 0d99578aa515653de0e379b9d166ef86a60e999f67c53c1e73e87e98d1cb66e7 +lib/codeql/xpp/elements/internal/generated/AttributeList.qll 9d0a30c7f71f5256c12fa2dd871d36367122e6cd8de9cebd687d7adcb5bc6e53 245479f69d77da9f2577aeb01938864b41ef706dce6fb11e7b8adb0ceb7e9f14 +lib/codeql/xpp/elements/internal/generated/AttributeLiteral.qll b0df692e05f87d26192ef6f9720a64d0d900f70a91722f2771fa5e4cd01d4bb3 192fbcf782bf84652ae7c66387ee97af465cc25d1b60daf49f58b01007790cd3 +lib/codeql/xpp/elements/internal/generated/AttributeNamedParameterEntry.qll 8fcbf28daf2da704c6414e09ba9872fd1232829f1cf129dc78ddc5de22aef86c 964f55e99b834284b1cf6081caade3ad2feafebfc16a2bd71fe13958d52d3ec1 +lib/codeql/xpp/elements/internal/generated/AvgAggregateSelection.qll 2d4214464088a36c63f2201d188209cc3453132d0fbb97dc03c66f1577ca36c6 23533fe0c9115a26e249e8d34268973f816764ab81b599f5ccb9b9724c0f0250 +lib/codeql/xpp/elements/internal/generated/BinaryExpression.qll 0f734782852a98c182cd83fae0695944ac84031eed5f8b444e55e1de75fc654d d0510a712f2edce9a64c948def338c47c76e3c8907942696e77f26f253e0477f +lib/codeql/xpp/elements/internal/generated/BooleanAttributeLiteral.qll 021afc70a11db77ee9a84f91b90e35d53590c4e3574774fc6c2452baa1d03bdf db140f8a2846681fb81f087061dbd9fa49adb6b505163b2c3eab7f2b63161dd8 +lib/codeql/xpp/elements/internal/generated/BooleanLiteralExpression.qll 04edcbbe148b4c5b8997b8ffb51b1f382ae1c18c68e71bada4944919f832f429 a337219a74b8864e4c71caa94754556678525272d87541441ea51f55f96ab9be +lib/codeql/xpp/elements/internal/generated/BooleanType.qll 9c707cebb40351849d6922763ea89a54bfbd3d89de43fcf7ee434f9e196c07ce e4371ef710bf7e9175e861c07e6395912563491c383d527d2e0dd712acff6ff9 +lib/codeql/xpp/elements/internal/generated/BreakStatement.qll 18373c1905e48c31e8b8be7541c1b263e3c9bda69ced1f8cae2573a6569876eb a185bdb78a5a672dc2ac4a3bb23dae39d5a950c26fb471c5f52c5f9f71fdd6ef +lib/codeql/xpp/elements/internal/generated/BreakpointStatement.qll a2a8cd8023f05ae2c1b91335461984af9ec8437cb7dc27bc5492d2f9f59dc799 6fe96f7c391585230eb49d52a85b9e3d131d08396762d50dc3b65f45b98ca6e2 +lib/codeql/xpp/elements/internal/generated/Case.qll 264735e142b7b31dc8e45d46724d2fef427ed57291fcbf5319188204eedfe440 dc32e2388d8dc86a62b7b32727d10c4fe831ec7cf756f0207554e27fa08e5c59 +lib/codeql/xpp/elements/internal/generated/CaseDefault.qll b96ca13ac302fecbacc922efc5ff058201d8183dbd7fd4b39bf5fb02428a4c7b ca416849d6576c8aacafc57b0b7edfee793e9c4a1a8a1679a08bd6022a149dfe +lib/codeql/xpp/elements/internal/generated/CaseValues.qll 79fd899820470782d5f1d4dc20616bfdd8b0004a451531e83ff7160e3dbf576d 47a1a0f08f26e9bd976fc54f3538161b3012688a446f22db42447cfc721df429 +lib/codeql/xpp/elements/internal/generated/Catch.qll 2731f078027d241a32ac75639b9daf9dc8429ed60273a592c56bfb3c2b2e8703 14ee8828bb6450dc729085ca529eed6724a911ba3b23b75c30f7107be4131512 +lib/codeql/xpp/elements/internal/generated/CatchAllValues.qll 34eacfe0370112e1204faf6dedc249a73aa1f38f77bb9df9cc6ceb70b13ebfa3 e9b1eaed91b185b63da14ef342fd718080507ce80b321e89068efbd219d072c2 +lib/codeql/xpp/elements/internal/generated/CatchExpression.qll 9d1f845f36d25c2e7dc4f501169a4602969a5ed4311860a46323c5e7318225d8 e7a4ceaa20afc39a41a0e908987436319567a931dbcaf2510361d167ab6334de +lib/codeql/xpp/elements/internal/generated/CatchUpdateConflict.qll 1ea34c9c2403345ee481915d50083988e17ef25d9f34001ed4b8f89139b4ba3f f121026a554ed37e2db316ed7af8914db0c7ec9b2ce8c794d977b2160009a4fc +lib/codeql/xpp/elements/internal/generated/ChangeCompanyStatement.qll 1e982b907dfc4c6cab1a55308b0fc289669899586af4fdae9c4e6958d8022c77 155b636ce283a8943d8c223af3903fab46535753c69d2a4a11268751f9f043a3 +lib/codeql/xpp/elements/internal/generated/ChangeStatement.qll d60b8d5bd2458169805361288dd7611f1955d6177cffe67901d469dc46e4510b 482cc465a9acd6077c8604a8788bfbb4f41d3ad4777f43bbd8ba190216388788 +lib/codeql/xpp/elements/internal/generated/Class.qll 036b52020cb0986774b8044b4dcb174e64c424d3485da70d57ad406d6d39fb2d 1c1d87299e2cab8f810fade8b92cc69bea25f7fb47dc6a5ef9896d5e84348d05 +lib/codeql/xpp/elements/internal/generated/ClassAccessModifier.qll 4794a83db34e8e45f861409568a058b2576cdae53c5952f4ed0881514a677ec1 f1dbb0db4e824a422bd2e25b109ca52adc5418b05c140078762143afcd77f598 +lib/codeql/xpp/elements/internal/generated/ClassOrInterface.qll 61bf3792ced84c4b24da2bb07e3e61f714efe5633aabffd09ceb21035076db1d f495821fcd0a93afb0b42932a19d9469755a7ac6aa1306d1b643e592b426d412 +lib/codeql/xpp/elements/internal/generated/ClrEnumerationLiteralExpression.qll 63aeb3ac4e8533647d57f5cd5275f3b2a21346cea6a4c709c075a55484e89e58 11ca5c5aa6ba29102c7d017a551e653c98d7ac2bc57435fc8fc3911ffaf4c4a3 +lib/codeql/xpp/elements/internal/generated/ClrType.qll 563961c291fa4674ac6060e9c12556a30c0124d6172cf033d5b8ce71a362e3d6 9f8bf92535c72bfcb0fdd249e580125db736f9aae19f890f18a8e0c996650d47 +lib/codeql/xpp/elements/internal/generated/Comment.qll 8f85f86e97d0f68bed196ea7b7c46dc136a0edbaf36c3e02c1a0a960bea243c1 49b9075af87d7be53644e00f29c6bdbcaf16d691879577216ff7d3697956a2cf +lib/codeql/xpp/elements/internal/generated/CompilationUnit.qll 328984aa34c52b965069ae1a02424337a0293cf2aba45f7e4523c9878a58377b 38c2848e12122e9a2e4bc7fc720a67071c5bfeab6d0a79a207d4b6726a7734e9 +lib/codeql/xpp/elements/internal/generated/CompilationUnitRegionEntry.qll ff77095c37563979d6ec247dbc1e132e9ed3dfee0434d3270656a169049de605 cb284183d5c49d9735ecdd2573b9f77798afe6c5ad013d1294de818060f8dbbb +lib/codeql/xpp/elements/internal/generated/CompoundStatement.qll 4a0e7cd970e48fe6546c8c65da63f88a169361bd23c28eaae40458c25f78478f fd1f565b5f19a11d22c398ff93d7d8abd7b0a13e438342e58d85c269f47c5012 +lib/codeql/xpp/elements/internal/generated/ConditionalExpression.qll 80e23d8a8f8b3f3d09cff22914af52321b71abedca4e03c2912381b63e658f38 a115b2ed8136b25600b84350abcba43bef4906e2cf6435818f276fe7c8301d1e +lib/codeql/xpp/elements/internal/generated/ContainerAttributeLiteral.qll 6e52b1a517740f24f5303e7abf3b25e34fa93c92f071de0da2ccaa6d91869d79 6c3ef553af9df4258d0fd524e12014cbf246498a2d14bfdf3e7cca4b4bdc0401 +lib/codeql/xpp/elements/internal/generated/ContainerLiteralExpression.qll bc52ee61b6e3e2b4c61eebf611e2bdf4c26fd39c032acaa0062cc8f49165fef0 1cd1d664fbdf774bb61d3af0e68228c13377f2ba546c3909333498a783a29602 +lib/codeql/xpp/elements/internal/generated/ContainerType.qll 9fae3ed763537a9a1d5156e8763122d6b7ad2fa037fca63a3ae03bf06ec70e01 e1a39b190585ad67e81540b6aa566ab51c2cb187e84faa4c3687e23f1a5b46c9 +lib/codeql/xpp/elements/internal/generated/ContinueStatement.qll 96ecbcf31d5b6daa5a63d37f99f21ace01f7d240afc7d0744d160f4483513bdd ac6a97a9c4ffa8937b3bae172e8bf1860742db38005f33cd80df86ca2707f6ef +lib/codeql/xpp/elements/internal/generated/CountAggregateSelection.qll f1e1d741886a00fcdddd0a677f8273f720e24b8a33c991e9674ab2fbfa193d33 ad719a2b49891076477465e673dfc5c1fcf33fec53ce3c59c009e5ca7233c050 +lib/codeql/xpp/elements/internal/generated/CrossCompany.qll 8e2465a9903187e8885507a2beed5a01210a9f6d86f5c4cdba023fffaa5c4730 f12fda0e372e4aca3c627cd8c271ad22066221db0de0d77e403d0ed256ffaa00 +lib/codeql/xpp/elements/internal/generated/CrossCompanyAll.qll dea36667338df6c0ef89f28139b362cba97ee207fe0597c2b3bea50b4c2cd86a 09e7fe9459e0ab987c4b070e786d8212591425ad1343af532fd098b53aac8879 +lib/codeql/xpp/elements/internal/generated/CrossCompanyContainer.qll 12f635d2bf3733687aa37d0f3d8fa412ca3b701bc58e9263fa02f66db89e1a5a 673a656c7c7f092fbaeca1965d8aa483196e63fafbde01f3fd4ffa8776b1174a +lib/codeql/xpp/elements/internal/generated/DateAttributeLiteral.qll 53ae6fa095326000acac25338c1651236ecd1423813684a5114ee3a64f4c49f2 610a9273a99b0491c7822e3ca1f313cb860a1d024c6a2fe8382dd8f27cab4062 +lib/codeql/xpp/elements/internal/generated/DateLiteralExpression.qll 97bab5a9cfd7ab4ed7f9c5edc52de7d86f04d955b9656707332f2c9a67e7d0f0 5444606b338c7ed38caca5b707899c89c4bc4448ec9fd4bcd929bf39d9676289 +lib/codeql/xpp/elements/internal/generated/DateTimeAttributeLiteral.qll ac418d3e958431bde0db3db3b40e2e79af69e00289dff2bf04bca86ca5113c9d 74637edd8ae28629e7f011f032d18e75d7e84466c7607f20ef45cfbeef6676dd +lib/codeql/xpp/elements/internal/generated/DateTimeLiteralExpression.qll 2e4fb1e054d4cae336fe408e3ba9910415d332e758152991d5645de012a058e6 419e0647f5c4a5fb64742c99bd32f0d3d1207607d45631063690b190c797af5b +lib/codeql/xpp/elements/internal/generated/DateTimeType.qll 647945dad10c9b0738658367f427b0a197ea1ee934b177d0b839fef5dbd175b7 899dd71bb8063e7180bf48140dc94e4d7d3166df7ccf3f982eebb02ad1bbaf0c +lib/codeql/xpp/elements/internal/generated/DateType.qll 13b0436983daf49b07a085341e7a827061c398516f981fb99a09ce73db499180 4c854a31f24c21caade835ca89cad87140900368f412f869d5e0847563b3ca9f +lib/codeql/xpp/elements/internal/generated/DblAttributeLiteral.qll 4427a40cc53588efc85d403f31547547278644250a94ab3b4d7f77d2eef010b6 b594dddd3d97b978a1b88271c5ec289370be30325eeaf4a257d183457e1fe866 +lib/codeql/xpp/elements/internal/generated/DblType.qll 6c3cda31e640f3c39c2eda3ccd8087fe9299bdef1b7718530cc5d9855b92c9b1 bd55040a62b1880b15f9af6fe55b52142bbbd791797306eb18e3bef9018cc80c +lib/codeql/xpp/elements/internal/generated/Declaration.qll de350762be8cda4fb5efd2317e80e9054e7dd0645b23205579724ecd4bd8ab86 b564f1ba2f2be9b85ed1df95ded3f5c32e2a71e651386cae1fc5b58ec578aeb0 +lib/codeql/xpp/elements/internal/generated/DefaultTypeAttributeLiteral.qll ff85717115dfe89baae08cdbfc6df26c81db039e9bacc7c985f0e3576ac40922 3f8cb540502ca66dd8dd7bc820dbd5508f8a11636ab3c054b5ded017ee96b1ab +lib/codeql/xpp/elements/internal/generated/DefaultTypeLiteralExpression.qll 354fd61ce9f5093e733d10949a68fe85ee51aad0ee956a8c7ac706529ad8a5be 2f7d8f1aa60fdccad2ef2b3dfdd6a42f3f67f2505d413edaaa982ad65951eaa5 +lib/codeql/xpp/elements/internal/generated/Delegate.qll eab06ea0b67398df849d154b6f28091078afc6d25896043a6cc615b3e2b35848 87dcc3ead98bbbad57b8df216c15f01db5e8aa433b13abdc21095643534745a5 +lib/codeql/xpp/elements/internal/generated/DeleteStatement.qll 7ce83747268b56c42ea4a848c802a6c0471c968c036dc8c199b2e800a77b14c0 c4449f7303a672132b56050937f3d132a384597cc5637267df896bd609bf3594 +lib/codeql/xpp/elements/internal/generated/DivideExpression.qll e1ad394daf5032c5b49fc4c118d38e3e7eb6176928ac689529ed8dc8fc9b9922 906a0065eec97f4ca6a203714b9d58e39300e5a0d7d10f8a39913882a8e2c80f +lib/codeql/xpp/elements/internal/generated/DoWhileStatement.qll 9845af473417d9a5b55c655b0dce8dab5b9864b22ccefa01821e7ad12194a6e7 5229c1961500b0b461dead823e4675419a095f5ce536b907fc6b95e0feae73cb +lib/codeql/xpp/elements/internal/generated/Element.qll 3264cbfa428d4db067e0c36b37b27443d8ad9a6cf14f1fa377281f36e60f76e2 30b7ecc622319f84652438a5eac18eb13f4bf9f7d45b39062977bbab49443703 +lib/codeql/xpp/elements/internal/generated/EmptyExpression.qll 113804358f6d491308f5829ae6d417eff09876652720e74a079bd70927b93819 b34dd0daeb125c6d112099045f93102fb7d8c521eca6853284c6e9e544c9fe0b +lib/codeql/xpp/elements/internal/generated/EmptyStatement.qll a23c100be4446d101757183a5d8206718a3d649dc762e114c59b48b053d939ff 53aeffe5eb583ef8bb0eb4b0d82edf51ec77a9063b9630134002fda2d5ba3bf2 +lib/codeql/xpp/elements/internal/generated/EnumAttributeLiteral.qll 984e9d41885bd11be533c09505af2693fe5b780e18d56485e0ae7cafb10b8122 562c2f4300dca7dbd8042cd2ac8be9ea442c63b3e4370b2d310d34d3417bb68b +lib/codeql/xpp/elements/internal/generated/EnumerationLiteralExpression.qll 32f457640232cd6e26ab7dac6f0832560de1501607c27a518688016add8942f0 0676a0afe63154b595074b1351f3b98981a4d84fc741e6d67d13712d426b6ddf +lib/codeql/xpp/elements/internal/generated/EnumerationType.qll d0f2ace21c65e06a050001951570110308d9b44e51c4e84e721eb3aebed09643 6b248ffcd572dcf9ee06f3aabf1b06dfe6ce856dcb1f71da2c10ac1d8c8bb78f +lib/codeql/xpp/elements/internal/generated/EqualExpression.qll 7d4b309d9324aa62261eb21dcaa6a543681e8cf7df722dfc55ce2d9fb334b747 3a6dfb2c8ea46c51fea0081edc031eac0e7e0ecea7f6cd940799b87f52b5ac8c +lib/codeql/xpp/elements/internal/generated/ErrorElement.qll cc33b5299db27af6f554b6d24773bb3f5ae5ea1d713d72122a96589412d928d8 4091528f438ec7b63edd3fe5b006a1128ecc4143c36139253f27b3e684b88909 +lib/codeql/xpp/elements/internal/generated/Evaluation.qll 94cecf5b91b8314af170d625f56841aa87cbad1c1360073330157164d0116714 50358ba6fce09462fbb4a22fd29dda3548eaa0ff2af0de83de4224932af200c9 +lib/codeql/xpp/elements/internal/generated/EvaluationActualParameterEntry.qll a06563c28c10219345059b82c7aaf9276e636d6070aab9f9f970b569f92693c4 3912831ceeec437f7fea4f31f84b61c118435619fd013da4cb60998ff71b72e3 +lib/codeql/xpp/elements/internal/generated/ExplicitSelection.qll ecf15e6ad78648045f230b6acaa35c4bd1a44e4f04fa1fc4bbf495e3359c3813 1d3d55c65076008f4427784a44d3c518324bb565c55382de072af6181eecbc13 +lib/codeql/xpp/elements/internal/generated/Expression.qll e8980edc4e656281c4a62c7f07083fe24104d1d2c4384be1726698fb25721f8c 53cb4a3df1858016096995a76df034e5b5998c78a78c5e903b80afe6b8006e0e +lib/codeql/xpp/elements/internal/generated/ExpressionCompilationUnit.qll 4d03c4f4f822de9cfac5871d38febba248e052bbaa9f3f7eff19cbb932570153 e3b90f9f97c370ceff8229f708dee5fd4e922a4c4d830c70e09f9e8fb6c970d8 +lib/codeql/xpp/elements/internal/generated/ExpressionQualifier.qll 8d426a9e721699d92935a33f837ed5d4cdded1cae431bdd26959bc4fa69e2768 1d3c47043780acb507370fe6dc2a10efcfe981296743a0a5d4dec69e74337d8b +lib/codeql/xpp/elements/internal/generated/ExpressionStatement.qll a7913fe3db6f1f2db6b2672df4e091073d30fe3f19ae9bbbebdc577aa432a56b de5d9ace507d5b02df21531b53015736258fcd9cbf0129855cd1c56e98e0f6cc +lib/codeql/xpp/elements/internal/generated/FieldAssignment.qll fa85036839fdf27505171ff937955f12983a84baf7d420db21bf22fe87be6a05 54f7c263590a61cc2729a52cdf7e5ba9e641f67544dd2ccf362f42d26fbe2836 +lib/codeql/xpp/elements/internal/generated/FieldDeclaration.qll 9074fe2229bcb78434a4e22de0ba43f7f798ff6290dc62ae946990b0e8cb158f d42ef1ccc480bbe316928521e659a07d6c2697667ca2c7f96189e8e42eafc4fd +lib/codeql/xpp/elements/internal/generated/FieldDeclarationInternal.qll f742be21332caccd8c3d3b9f82c728700c83c164360314a7a2f03999e2dba1d1 3df596ea47204e10e99a275414fb9f26df7989ac7ea3ccad5df3fa994e80670c +lib/codeql/xpp/elements/internal/generated/FieldExpression.qll e0700eb07d256ec104fac635103ffd94760f25f8ac9515c4ad415740b9d10d0d 71281fbf774cc080b960b5e7505776225c75581c09347445b7576477cf9c8207 +lib/codeql/xpp/elements/internal/generated/FieldExpressionInternal.qll abd20abb2504ebb04e76654118e62f08e55d71396817ce5b61939a599ee1af64 094b8ba5a2d2d41faffd78a5e7a845436e38d57a7a2efa0c9798a4f3c7263e05 +lib/codeql/xpp/elements/internal/generated/FieldSelection.qll c3b42136c0a206de86a39ba70e6bc13c94a8149161dfe266738cfb932c1546de 723eb15f1f1fa29692d8519ab93541f53246c8e0da7639b11d09fd674886be36 +lib/codeql/xpp/elements/internal/generated/FieldSpecification.qll 4ce8f04ff09a970e4e25ebe9cd83cc50ad2e4795f2e14e5c4d680da8b7532106 039220c885d3f72d53d21da58668bed85ca5c6c53f99fae516e8ca6f882493fb +lib/codeql/xpp/elements/internal/generated/File.qll 5b513f0b5f01a795eea337aabb703fc8310d4627ed9fbc61471a2ef60c1438e0 8dd2a03cc2569320e7e9d1abcf6b32dd630b0c8dcdfa3fec2c19e612cffae0d0 +lib/codeql/xpp/elements/internal/generated/FindStatement.qll 402c411a717c439f4127635de4c99e12e2f466a2a19a5460191fc58f89f254b7 af5e1913988c905139303e9c30077bdce8f58e747839076f575cb05d4cf9fe67 +lib/codeql/xpp/elements/internal/generated/FlushStatement.qll 0b94cf3892d8fa65e1b9c1cfe2b815fed08cfa8f26672e57a86a04eafe48280b ed6330af929853480ab44073fe0a722e9695f5d65cf3b5f0267e6671255cabd4 +lib/codeql/xpp/elements/internal/generated/ForAssign.qll 4517c397c23f5eb68cd0d31ef82faab05dd3a641b514924d032eea7d610f0569 4ab1b9446b27dcb705c7222d5204fea7a33a411c7583945cc01ca519976948aa +lib/codeql/xpp/elements/internal/generated/ForDeclarationAssign.qll 61bf363713c19526f251a22bb2e3c8e15fec3d599a3dc0111e96d58fbd9cb0fe 4f16fa92ecf3439826c83fae4fc122500c28ab4911ae92f8bfca58247ace386d +lib/codeql/xpp/elements/internal/generated/ForExpressionAssign.qll b781e5a532beffadd3a1db941c148d45fcc523f84fbd522ca83d6100d9522c97 40b81244476b5503d545a2f24a52d01b23216c12d0e6e30b3b19e309110f85fe +lib/codeql/xpp/elements/internal/generated/ForFieldAssign.qll ed43c62603ea0f0ae9d4e2ee5a8236b869b9523846a5acb2b3676975db3d474a 2a4f0a02033a17208e2ab37670e8ba3dd1e54004c2021d10c3d9b27f7845961b +lib/codeql/xpp/elements/internal/generated/ForFieldDecrementAssign.qll df0ac906760c0113ad7dcba2c738f1fa44317babc2c97a8f0b52767f2c6db0d4 cae03a0ce6a586d6893ee3ae4fdeabfa5b4765ae521cbb45d9c8798e4c000375 +lib/codeql/xpp/elements/internal/generated/ForFieldIncrementAssign.qll 4a27eab00bfb36e648b199594d10a23416d542cf00c80c40b94e56d0e103b357 0a60ba5d89a2c7123dfaf8d109131aabc371641a07656cff2854128bf46e3a42 +lib/codeql/xpp/elements/internal/generated/ForFieldPostDecrement.qll 25e06b1bd5d39f66ebf695223c8e704f92d7e176927558b595d8c8a7dda99957 87ef11076bf86e397da3e84bceded0968cf2bc71a2641158adbcf3a02d2ad10e +lib/codeql/xpp/elements/internal/generated/ForFieldPostIncrement.qll a28c04aef6ed907c70024d48f4e3617194be03467ab3b06ed92611bdc49dc1ec dc7bedc6298b8f63892de271215b0a7c2bf504d98e9a36b0a90b91b423aa09d5 +lib/codeql/xpp/elements/internal/generated/ForFieldPreDecrement.qll 32f89cef4becc58713b6263041136d73379fe05b0dc4f637a7f1dd5da16b4b0e b75775006389f551302db728370936e653f08ef63b17fe5f89beadc1f7346548 +lib/codeql/xpp/elements/internal/generated/ForFieldPreIncrement.qll fbd7f26f4fc5908a9855cb385d4fbb4694c90b45314611d321af45b653a59e6a f39e6695627a607dafacf79635b08c38f77220e91500b72446c404ac988e2cf1 +lib/codeql/xpp/elements/internal/generated/ForStatement.qll 7fb346ad88d4dd16d8f50eb7276344906a02b5cf53fcbb076d602211da364799 1d21477e128593d6b2b4c275d041abd7317aa439f7475a4f580a7cab8390a6f3 +lib/codeql/xpp/elements/internal/generated/FormControl.qll 7deec5a53d29aef36ac5a43aeb382c89e4976e2172e563a3baf2c4dc2af4f048 797646344b6242c11bf47b4a33eb5962d21e8242f7584201a11e1b91b88b0a48 +lib/codeql/xpp/elements/internal/generated/FormDataField.qll 94f3a66ad36f395f41e46556aba21fc35e374b103426615601176e43bd6b3a42 4ccf113e9cc8fa949ff3fe46d29bf2d25f0609b767d93d78c12cc0393d449055 +lib/codeql/xpp/elements/internal/generated/FormDataSource.qll 2ab8b01013d3a2ecdbf2ab2930fb4e9e9de5997fa1aa35212cc5d411051d4a80 5c57291971bb60eaf68e2ad40d421253e2250bc4b1c1e602dbe56dd42c12b4df +lib/codeql/xpp/elements/internal/generated/FormElementType.qll a63f5fe2a3e3ec5ca810acbdf4067e44f250911b988758072eb7576804e62d17 8023acbcc19ec47ea83eaa97e18cdd015a5867d8f62ab787c8b4d75e25a79e5d +lib/codeql/xpp/elements/internal/generated/FormModelElement.qll 7da41cd85be377653e099aadbab63a8d4d2333e18205bd19a09c6d38fb37a35d b24121f30d9a3cdef01f454795b599bc503ad65492810c4a3160e076be5602ed +lib/codeql/xpp/elements/internal/generated/FormNestedElement.qll 92af0c00940da283366b06eaec89a67fc3c7b8f28fab0eddce17d111c20aef94 78fbbd692182fc61c686aa43fd40ab4f24b1ed6817b0cdea70330a1c436608bf +lib/codeql/xpp/elements/internal/generated/FunctionCall.qll 87549f75d2bff16e684d2bb5c74eba14f45dd755f2f8d95d170a46dd1faaedca 00c3718d711377505ac1e57fde6efa21cc33852170ad7f281039f22738d7fd0d +lib/codeql/xpp/elements/internal/generated/FunctionDeclaration.qll cdf71180e7a99ae70350f4cc081a499408d154bb4adad2b9499376dac2b89b22 46e670424b94b5151f4c03399637b4c69384342303cc17990f68897dd85a7cc8 +lib/codeql/xpp/elements/internal/generated/GenericEvaluation.qll 6153e0cabfeb08adae23713ab374646411b92604125d495c378e4f2605e88b82 78a9f0dd831bc3ce67f6f9c2ee4ff6a15f58b9494c2c848049d0849f1b561841 +lib/codeql/xpp/elements/internal/generated/GenericXppType.qll be7052516166b0885165bfa1486d20f79c9488feeab8e7363dfcb39896785859 6a58688c02b9ef99b470b41ee15b7de8b90f6bd235f0a7537fbd2a3210bbcf5c +lib/codeql/xpp/elements/internal/generated/GlobalOrderElement.qll 529f631f214552cb08866a70eeb7bdb2311eb266d8ccbeda14d37d473586fce0 b0ad82ffcdbcfb700c273d5bbaa6b81f95adc2b2819e630ba565e54db7183d90 +lib/codeql/xpp/elements/internal/generated/GreaterThanExpression.qll af954377f284d15ea148627d99ae08de8d039737d8b4199ac5b5d7da7d6a5863 926a589aa158961ab9bef29ce0d1d2c23000045fd316098c49d7218e7b23f514 +lib/codeql/xpp/elements/internal/generated/GreaterThanOrEqualExpression.qll 7555c7aafb508ee5f28ed1ebb58b02e1400eb32ec74f6c1cc2175451ae1c53d4 09f099cf695d9c6f97c97656c9b994606bd354477122885f844935c55fd2ff8d +lib/codeql/xpp/elements/internal/generated/GuidAttributeLiteral.qll fa0bbd50dfdd488de7975ba624e4a94fcb8713be00b19318b52b579222b9f5c8 19f524680511cabd268687161bddec881757d65872cd9f6b04d83128a8a04e2e +lib/codeql/xpp/elements/internal/generated/GuidType.qll 85b29bbc22a3afcf9b2bed78dc9caf5bb940641c5269d72d6dc806eaa51e5b81 6552597484b570ce3f0103e30b262c08819c547b3a533b5e5e8e7439e614f7e0 +lib/codeql/xpp/elements/internal/generated/IfStatement.qll a3358c9ad872b857c86eeef6efc4c21ef8220911d821faa35b35ff4acdf92145 faf23165ae33a729e1a16368bb70c67a45071cbbdb97587b7e7943e32550ba63 +lib/codeql/xpp/elements/internal/generated/IfThenElseStatement.qll 2398a2335cbe91ba86619bd9c4de8df7cf5e10df8380126916cd43bf582ad3e8 d40de00a33d733c6886943b7a5fd5fe759d4b1f8951c5a8cb89af59896d6eeb1 +lib/codeql/xpp/elements/internal/generated/ImplicitSelection.qll 98f37732fe275e62661c3ca50c4556d72cec9002a376c9b08c1f1a0c48cfd0f5 56a99fe7d286774b8663c024edef93fc048c87d30ccb85051cf2401688db59cf +lib/codeql/xpp/elements/internal/generated/InExpression.qll 2420b1eba2714df899d97bd3f8e58d7a4fe049dbb53df737423ec0a847311e76 2cd44e7f5114a5044a00e7f0cef4339856a9a0547c8666e7f2af92220a9cb8b5 +lib/codeql/xpp/elements/internal/generated/InsertFieldSpecification.qll 67c5ab97f471c64fd007f9d7935828839a50e2595e517be87565528a6b8c21b9 cf5e37b0178970a8df82c3d18bf440855bdd00c404d06e277a92716e8fbf9d60 +lib/codeql/xpp/elements/internal/generated/InsertStatement.qll 888789aa4d7fc1666ab8f7bcd3285e71427132f9302c245935a2b59d5c98580b 861752577c0af7ac7123f3a20f17ee7c164abe927656a65d0d6b173940163d02 +lib/codeql/xpp/elements/internal/generated/InstanceName.qll 001373fd22d9b8e58010c65b874eb6d1b5c1bd9f7a9afdb9f55b777eb133d357 9597108e764ef196f1e3fae0ead9bc207800a0bcf7c3c7de9924821e17d41977 +lib/codeql/xpp/elements/internal/generated/Int64AttributeLiteral.qll ac23047ba0ce07dfda2a8fec0ac924348a3e6b8694b2f7fca671a1e688c32c8f 533da516d6594f4c84ef747d14cff4be13f23e50ab1b923f453e718dd5aa34b4 +lib/codeql/xpp/elements/internal/generated/Int64LiteralExpression.qll 78eb58a6a676f537ff23de040febb68794a5703e9bda676ab8d643fd870a5710 67f690b97e62cc41609d7f2c43ba6f6c8c01ab9974133aa0955a02dbca385640 +lib/codeql/xpp/elements/internal/generated/Int64Type.qll 01fbb1ba95b19a4d3075df57979269d0d0274d281475ef65f51c85f208d7df5c 400b9f82602592ed005152c6e64f9c3259f419c3b585a31a2788e5e388e6d7c6 +lib/codeql/xpp/elements/internal/generated/IntAttributeLiteral.qll eef9ac0e7f2080397caa70c64d78b591d8c340a26f918e4c3460c348ddd63bf3 94cea2dd6601d54390c06265fe6a7d839741e5ab4f5279e6f50550a9a6f0fea0 +lib/codeql/xpp/elements/internal/generated/IntLiteralExpression.qll 3893de237129e642eeb1a45a6c5f8d59979714ae9b7e21d0453689b1c34cf33e e40b3da7147c008c527ed697f3f87fb440135b147b6b6d8878515bd7e67dd5f5 +lib/codeql/xpp/elements/internal/generated/IntType.qll 5b326106cff5a29d16f30d50dff79495374e9e8c9169cfe933ea7dd3afff7809 f84978e372a711161d762a2f081a28a1f93c016484674e8f787068bce14d90db +lib/codeql/xpp/elements/internal/generated/IntegerDivideExpression.qll 4567b320045818cba40bad7d898bd98431a66078bd03789f35bfebe21a23b16a 48fe8dfc38a4b0a0530832ef6d769eeb5cc05f577de83803e73dd6e2fe720aa7 +lib/codeql/xpp/elements/internal/generated/Interface.qll 9f03ead2156c688100a52d6c8e44f0d8f0c9f045f5d6e3c0309a3b0338a522fc 180546d9d30c7f1d14b2efbad9c9463260ba2d6d0ef4ba2df6aea76f78a7d12f +lib/codeql/xpp/elements/internal/generated/Intrinsic.qll b2975089d402db2966a93236992f7b1826d19207ed04e92e5c8880b099900fca c84457025525b9e5bc935121099ee59b4662083f26ebc12a05b1a94ab1b0b48d +lib/codeql/xpp/elements/internal/generated/IntrinsicAttributeLiteral.qll e611385eaaa753d8da14c064694cf338ac277dc141eec28719e69461f92e6892 a42db2862cf1ac6ec93cc081e0789b48e2d00abf83cd06075a94b99ff19ffad1 +lib/codeql/xpp/elements/internal/generated/IsAsExpression.qll 3b1324ba03e0abecb4f840b4ad31c8fca08d76c51d85d2ceb9e9caf81fb7899b 7d6d05d077ba4e388754a24bd17b38d0f22f3c47cf931e30160543181946cf11 +lib/codeql/xpp/elements/internal/generated/IsClrExpression.qll c6eae6c04d31905225cc6aad9dce55da331c2d10ffbcff08fc9ffc4f895cb375 483042b88ddf34f47907412eeb4fc157ab5bd86e0deb56661beb18edb5701825 +lib/codeql/xpp/elements/internal/generated/IsExpression.qll dac001b3241e1277d548b0dc0e1e335f146af8fa9a99dcf513bceac9e7058c61 69fc754b4cc964ce1a230d40d655a3b4bab06a1310a2992ceaca21fa09d12183 +lib/codeql/xpp/elements/internal/generated/JoinSpecification.qll 345046697057c73a46f77603fb0b877e52326f73e910487569d5f180866d83a1 36890f841582a556d474c640a4477d24c83c4f72ad5c2c26a79a9706f586e3ed +lib/codeql/xpp/elements/internal/generated/LessThanExpression.qll ef2da00b6f52d28c108f6590aa46982af47afca4dfb5113406f3f0ff8e892f3c 778de1df6a4b25ffffd6bc1bf9e7ab8d633f10d92b64764ecb317cb414063177 +lib/codeql/xpp/elements/internal/generated/LessThanOrEqualExpression.qll 934174cbd0e310f9849aa5aa77801a8503f896238a7fcec679961216b339de9a eb7af742b8a4c40ec64774f1487cbcfeae592e64879b04d333a4ddd4ceb1be1d +lib/codeql/xpp/elements/internal/generated/LikeExpression.qll fc014f06fe059662690a26c8a42c84ddde13011196d1754951bf26befe0b2d55 f3ae26c0c2805feb5d4cddc0e582bed14a11300ba42db4cf0ddc4d500f6c56e3 +lib/codeql/xpp/elements/internal/generated/LiteralExpression.qll b90f6945aa30ed1ead5693daee4e70e9ee6f7a97f6b7ee22c9849ef19d2e2506 eee24f9130e1deeb7eaaa2166af953de4fbaf7309147a2633cfb9d846884eee2 +lib/codeql/xpp/elements/internal/generated/LocalDeclaration.qll a3b95e072be063ed02809b1e2c3f9e93ae7298e1796ad1d06d5ee97f0c479e3f ca975fdd5122c59819cd58cdf5cfb0841226861d6d0b9cf490ab59777520cf63 +lib/codeql/xpp/elements/internal/generated/LocalDeclarationsStatement.qll 010807b315c851481e3290574d8ddc6f822054c4f2313e7b93c8d96bdf835aef d7d9fdb9261d79481c7b9f8883026821f445a6e93eb2e310d046d66184718cd8 +lib/codeql/xpp/elements/internal/generated/Locatable.qll 40390a132a9e07a4756120c28f3eae5ca7398189a95cc1fa9c58dbc13d203233 1f80d050affbce2eefd2d6b665cb4f86570dbd61a39722da3960e1a0d31c426e +lib/codeql/xpp/elements/internal/generated/Location.qll 3c7f1a39ac0aae5e5c037607d133f7b636eba66d75ba0888938668ce1fced413 04e73ea29a7ffc725b8eb4ee772b5cd121ff7ed9727017466a4d9fb2e85d1165 +lib/codeql/xpp/elements/internal/generated/MaxAggregateSelection.qll aa67406352eec82c753259c76a2dcc64ed58b12cb473e38d69d46916b89f059a 1f23d000cebb811db705583004e90715495ed5c171f578978487f49137255ad1 +lib/codeql/xpp/elements/internal/generated/Method.qll d1a4e74c500000f5b52bc48c911394aba3790f5b55bdd626a8fe95126a573a7a ad3d0a10b8023fc32745b8c59f3103ccf20cf72d6ae62c3775535b336971515d +lib/codeql/xpp/elements/internal/generated/MethodOrDelegate.qll dde47d9c4ee60cc4daaf336a91f5762bb8b50050a9dfdec82d8119467b239549 e16edbb6963a55eae6559b62ecd1018a2160be014d29269f933864a5824538c9 +lib/codeql/xpp/elements/internal/generated/MinAggregateSelection.qll 44049d3ccfa4f3e5ff951c29dc0a17038e5e7186caede082e2de29ec9825e408 b539108fa7d4a86ea3678e8b6feedb4c0bd32c98045fee21c0e8760cbfebf91e +lib/codeql/xpp/elements/internal/generated/ModExpression.qll 0301ba22388abff8abd6f200f290ee4c7904bfd04878c27883ba94990c49a00a 0154d8fcc6cef00a5494b36d030aa0054e9f9f4361168904426feba4db064111 +lib/codeql/xpp/elements/internal/generated/ModelElement.qll f04291665f07fc1848cccdc910e62436295e363b006344fbb92e38e0359587fe ca67a04a451d0991163e4eb921478b08b2c561326991f6cfdb5e20f8f41d0515 +lib/codeql/xpp/elements/internal/generated/ModelElementUsingEntry.qll 85b69ad6b51fbc6f16b33570ac3dcb2662e2d4f8dd6291f09e322aecd111309b a94b5bb9e6b97e6a05b66a8f8ffb249bd8d23b5bf3a41c0ae4353965e87baa74 +lib/codeql/xpp/elements/internal/generated/Modifier.qll 571e476f69af4d8525b1e0e2320781f21cf0bfbc6030826582a9bc8f040f3dbb 38b49c257ba5b9c41802f75ebf5a8790fac7daeacdf0defdfedecd3c1315bf2e +lib/codeql/xpp/elements/internal/generated/MoveCursorStatement.qll 818691e1919aa178d35504b135deb761433cff3f22357f5c8b6717bb9a39f8bd 6d20239f6111e480600e5ce0bd350eb9008899f7053593665dd5747c6c5d160d +lib/codeql/xpp/elements/internal/generated/MultiplyExpression.qll 9170c3a4d96c62597b9703a53e76715b6104300ad12e8bd5ccb56de5510dd060 33c0abcea9b6253f957c4254a18c31aa0105842cb1ccb6e215857a62d3fef719 +lib/codeql/xpp/elements/internal/generated/NamedFieldReference.qll 2d23cbc40e442b2edd546dc764b8bce50058d731767a960739aa4b4fc4175c5d 0901dd8cfde4609e78a80a4704926b308c1e924de611845ee9ff716b548212d3 +lib/codeql/xpp/elements/internal/generated/NamedType.qll 12d5e5d1d38c2fea83a68e52bb6d20a65e358f4943545667dc35aa1f5db5f775 ddc66b33cd0243796aa6ee2d50855e7d97790946d84b6a2e51bfaee9bf2f8339 +lib/codeql/xpp/elements/internal/generated/NamedTypeInternal.qll 0d33c7296e47091c54da61c434a2fe716f865867e72844a79e61391866298e7a 05b64ebcb73c77194403c5d4ff433e2b43948a1f81e0f497cb29da16bf029b3a +lib/codeql/xpp/elements/internal/generated/NewCall.qll 7140a9f58b0e2f17cf7125b4ed4c3524ac2a0e09c711638409d04f827f16dc7e 153d94f32b627687b896128847755d8c6b08a2b9a7f039a0f7920ddac9f45b45 +lib/codeql/xpp/elements/internal/generated/NewClrArrayExpression.qll 83e81466bcd3f57205b20e24b235e24b978bd8b75f335edd7753cd5e141d1eb6 dcdd960438f6aec0dcc6477a9c6910e1b2bdbdc0bea87355ad9326c4626d5871 +lib/codeql/xpp/elements/internal/generated/NewClrCall.qll 4a91ca191c798955f30cd7449c3474f81824a29079c1534c96b6d3f94ba5e870 3943f328f205a047c121c84923e7da58bd43bff3a52d066a9de5181c40175db3 +lib/codeql/xpp/elements/internal/generated/NextExpression.qll 1de218a6bccf13107c6f1bb643e58b1a2aabf3cd93218fa25c741d2b1dab7369 0fa84805866e85d12944dbfd64149464b287ce4d8a37d8c28470d4701aaaf659 +lib/codeql/xpp/elements/internal/generated/NotEqualExpression.qll 9f63460436da86838a300c13590544b0844dc39804956e3cb9579d8ea359bf6b 3ed921d922017038c7d5e8e1bb707945facfb61dec49b4b497e05610a38463a1 +lib/codeql/xpp/elements/internal/generated/NotExpression.qll cc778e210ca0bea24f901fec3e7207734b649b5c676023606312c1a9d1e005b3 86e5406abf3df3ab1f09f0770ea87966d12942ae10bb7a0a2d8fd84c4d0e192d +lib/codeql/xpp/elements/internal/generated/NullLiteralExpression.qll 087ce0d6cb6b4671a0e3387b78fa60db65c6e833fad420c87903efa357f234b1 9a79c1da8f6d4f717ec813e46c8563ed0215eb1c2e4de98cc7b4bd7a5e06c053 +lib/codeql/xpp/elements/internal/generated/NumberedFieldReference.qll 6f0fc2021ecf0210d96fbc0b39aa6403cefb8152f0e7e769b78d92783f4e022f 163fefada1873ba1563ef9987714e7a13e057bb9461bf6cf1ed25215911a6a89 +lib/codeql/xpp/elements/internal/generated/OrExpression.qll c19f2e4612a7732a1d59d84ca1dac75cd902ae3f7e4c9b8971ac9fbb06228b04 db019604ef256655aa77acddf91d228cc3476aaa59ff5a70f8f92567a0604a6f +lib/codeql/xpp/elements/internal/generated/OrderElement.qll b333f68b344f489db1555582af7594baac5aabb868cc043e89dfe4f63fa783fc 741c88f6f6ccf13afcb6d7895a922f1e765b3c513f23d456924d19306003125b +lib/codeql/xpp/elements/internal/generated/ParameterDeclaration.qll 474a4b818de809962ae79c1b41c12bcb2c7680fddc62240d5d4e717ce1fe5431 6401a802d23fa0ccc1a297236da1c7158d239e1d62b9a1444355097a7fd44159 +lib/codeql/xpp/elements/internal/generated/ParentChild.qll 91d64a93ea85996bc3934868701e74691a66a2a3067e4e94748f4c6dae11447d 7572296ae76dd7d4257287a4850aede61ffbc5f8b96c73cbc883a7d41b24acbe +lib/codeql/xpp/elements/internal/generated/PhysicalAndExpression.qll 26a9758d670ef5c0cf06b12cb6942ca6fb00f5d9db6c5537dabcba9133b6efca 0d1a5091a5b1e70a0484e28d2def4cc1aa265fa3f053a066538a828d3966a4c4 +lib/codeql/xpp/elements/internal/generated/PhysicalNotExpression.qll 0603caca232f3c9079ff0ed74bb690bf152b149de6da8a73f356acbe7d064a14 c38194e41a04c523dc3800d90e3ede87618d6e18104a83c55867f54d44f352b8 +lib/codeql/xpp/elements/internal/generated/PhysicalOrExpression.qll c83c2128d7739543e1bd1c94b20998fc5b29ac9f791d0b7b189e4d20d723529c 8f21100dbc5386ac7527f6a809a8064c94ad7b784a3af8f00e4f42e38cf20f3e +lib/codeql/xpp/elements/internal/generated/PhysicalXorExpression.qll a71bcd732fa69eac5d21fb77d0829ceab5faec5d0cb5ea41def3a15114536af5 7eed7207d4a2dde6baca61ab247ce08f58acf11a5cfd922fad31eedf3fd633c8 +lib/codeql/xpp/elements/internal/generated/Placeholder.qll c1a5c9105fb81b110dca62141795cca1e57fd0b42463270ac09e5ccaa1108e63 c540fe91f44b77032812e95e55031789ec863cead93b4a62b9879f85307466d5 +lib/codeql/xpp/elements/internal/generated/PrintStatement.qll 2cda564faa67a3bd9990e47a1949f0f17f16e071ef54053cf1581d3ce72c752c b9da22dcd80025ef2346b179a4a8d08b4a2f07f7db805ab6716c72ffe85cd7c6 +lib/codeql/xpp/elements/internal/generated/ProvidedType.qll cf2249c54cec90d0863fad048783f0b0429362ff1109058aebaefd82b2c15c22 25c9a300b6d23a7df2c3ee6b4be4c0b0205dffeae47e5b62adc2683558c50a72 +lib/codeql/xpp/elements/internal/generated/ProvidedTypeStaticCall.qll bda3ed548dbed817db87b3f8cc54cba20ec04c4381c570e11f41d612de2766f0 8b2f111b11a046afcf686534e972831a852395b753301c664c89f4f68670c463 +lib/codeql/xpp/elements/internal/generated/PureSynthConstructors.qll 452a7e3c4651d26124d92bc6b03a0c51498c465c4ab052b21ac8088013c5a941 452a7e3c4651d26124d92bc6b03a0c51498c465c4ab052b21ac8088013c5a941 +lib/codeql/xpp/elements/internal/generated/QualifiedCall.qll 879c61b709898655fd708a170af1b55baa78aaef02af3f657f3a6c9d6779d185 76ba4f83e9b2d0d66906dfbda35329378a4433bde2d1609dd891f3d210cf9fc9 +lib/codeql/xpp/elements/internal/generated/QualifiedField.qll 71c1729d6871c14391d16dcacd55e4c0982a7d14ef5ce0b3ce1fa00943e8f72b 1c6e2ffc33823eddfe56c2244801a87fe7aede81ab22c9fe12474624861b42c8 +lib/codeql/xpp/elements/internal/generated/QualifiedInstanceName.qll 2f57bd1013dfab359bb1f35e6b0405aca608847541945cf3190caa4fd24fce40 ec95bedbc554cec5d1d299c948fffac2e9ebe070c0545f4d6873d9c2c1cb6684 +lib/codeql/xpp/elements/internal/generated/QualifiedNumberedField.qll cb17b84a7b64b2bf1241a655942aa371d1a683686b6be77b7469bd4b4e025f4d 9e44396dc30934a012406aed5a78e5d6f28dfc0f6fa54f5a0918ea622d9535cc +lib/codeql/xpp/elements/internal/generated/QualifiedStaticCall.qll 62df4582a656a4b345725f125d9f88c7fc32f740553c889b87830dfb815946fb 985003ca49a59588653fa5d3d4bbd34afdc0b345ee1511e76b0aff16b32cc2ea +lib/codeql/xpp/elements/internal/generated/QualifiedStaticField.qll ff93d50fb965eeb2eeaaea8172f5cd2d6a66f38011bb5e820d15268d7e4ab02f b44662e7e536424046af30c214e5833e081f79afa06c6645c27d650426344654 +lib/codeql/xpp/elements/internal/generated/QualifiedStaticFieldExpression.qll ad4c8df0321ce1b70a4dc99f893fd365f2efb727efceefcc1b84209012e9c849 8881ed4b42772c279d364e826f40c56779d819baa55ca9cfe5f469adebbd8d26 +lib/codeql/xpp/elements/internal/generated/Qualifier.qll 3d4f61bd072d1317ce6dcf10140996e4eef0df888c16eda3238d7f8ca6a3e8b6 3abcd501d24cc40ac6e8b60c7ba051053787bae02f78a5ec2808bb7822f71070 +lib/codeql/xpp/elements/internal/generated/Query.qll d6a208ed9651b30dd61ecdb07c78e08c6d54ed77464270e00d7aa0434fb39a3c 178076a4f197a0e614c14425a04bd593788cfa0b56800e267ce1140c32f82b4b +lib/codeql/xpp/elements/internal/generated/QueryDataSource.qll 06c98db7522ac044e25f78c1cadfbe978ac2109bfeaf1fd035febbd423320f58 40397a6c5fe930994b6b772f1d0114311263ab0bf4636f37ea790ee144429d9b +lib/codeql/xpp/elements/internal/generated/QueryDataSourceHaving.qll ef6d7ae383e39ba0db19d886513f00321add44ccfbc820a60794433c3f2eec9c 190ccbd438e777233da2eb62fed2e65faf298528a0b7abad1af8e6c036617e24 +lib/codeql/xpp/elements/internal/generated/QueryDataSourceRange.qll 08c760d747598f53544fc966103035df8281ea7acc82b51faf3de30038e605f1 c5a9d66105e5aa285e7f15745570e550e9fdc8fd8fd88e987d938dfe47ac9a18 +lib/codeql/xpp/elements/internal/generated/QueryDataSourceRelation.qll 63b2340e4b4eecde1e6441604d66fb3b009a0151e11d0d406623d218d0f98399 be6a885094b874c7c88bbf2e4f11b7848f6d9c908b0e3a95c9e40b85e4eb2d31 +lib/codeql/xpp/elements/internal/generated/QueryModelElement.qll 2a0aaf5a2e6ac7793c7cf360f7300759e874d9c3406d8511cfb51c4fddd83bd0 e0d21cf0c3026c1b69cfebd9a68ac24cf8f98f858cd0a5b9f85a95cf88bca20f +lib/codeql/xpp/elements/internal/generated/Raw.qll 5e3addfa51975a15b88e4f3c1958ed6093aa97359c06d388c554d0c93422b914 8130aacb9ee340558625c8104425a80850c7ae97bed1384f5bc8a9f213a6c81f +lib/codeql/xpp/elements/internal/generated/RealLiteralExpression.qll 4a4a8bf57cb40372c704386984644ab265d4714ccf64ad40dfd8e619aba04fbf 22d61d4adfaaafbe8470f2269491cc0b9af6c2b04ee5dbd816f67cc4ea863fd3 +lib/codeql/xpp/elements/internal/generated/RelationalExpression.qll 19d8251ad45c4bc92b55c854c5b2371c6d3a9013f4fa1e2d8438106e05d03b7f 6544ceb88a650841cf6f6b460148f8aff27dbf344236ab28301f254089fa6440 +lib/codeql/xpp/elements/internal/generated/RetryStatement.qll f2fd95952429d5c52eac6c8e342c7e2d971a73d51d14e011e644883fc0b8a14e 7f28dfca90dcfc9b6ad3a1d06e1b31495b0879ea5974227b3ed2d67e9d1e6619 +lib/codeql/xpp/elements/internal/generated/ReturnStatement.qll 198163c25354608f86933fcb1b95bce25fc6bdb5a03d9ac61c35c0a20a8c362b 714b26b3c83078a54b5fce16edc3c6a982aa9f0ddb610eb8f8f3c233b6aeec28 +lib/codeql/xpp/elements/internal/generated/SearchStatement.qll cbe11f908f8559e2c629a5a4cab44f89749a67d41fb3be2e7634256ff134843e 4e0f187b75cc9cfcb15df922ece105241d398ae58c54fa467ff9e59c2eb31eb1 +lib/codeql/xpp/elements/internal/generated/Selection.qll 31d110f60f15758d6f32e6074fbf9d464203ffd8815e6bb29779aa4da15846de cbe1d7655ed24cf1d4d2cd1811847ab9994ec20665330f1bdd4193dbe400e452 +lib/codeql/xpp/elements/internal/generated/SelectionField.qll 67b08ff14f0909ab0d46e6b8d23ebed9ed62760bcca17c4c9b185da81fad27e0 6a88a6e66f65298fad9cf7e4da28e1e83cbdee0217478676ca0f7c941f515da1 +lib/codeql/xpp/elements/internal/generated/ShiftLeftExpression.qll f701fd13ad2ac050e8a60668443d1fc09a807c859a9b85a53c2791b6bb60dd9a 29122fe0403431a4208fa8d7203b75e0f2169b02d35d73a73a77fb21be6f4e13 +lib/codeql/xpp/elements/internal/generated/ShiftRightExpression.qll 30189e69865929884fccbebb42f1000f269bbb17432457331088ebc623b902d4 917413d17eecad26550d47981a700af8c10d8bd1be74d419f0a040f99b6135a0 +lib/codeql/xpp/elements/internal/generated/SimpleField.qll 04f096ba9cebd63f5b5782bed6d7be2de540c79fc51eb42a2ed6b866ceca6222 178ddaa9b87b1ea24490373ab0380f71ab3cd40f3daeef22d7b59b5ac58305de +lib/codeql/xpp/elements/internal/generated/SimpleInstanceName.qll 6dcd64087aa734ea62982390df8ee98131db7275b2eed9ebf526dae45a38cf4d 2e33ef8fa2710858c378f9808eb33917cd8d76c36569f68d18a9a63b8699e85d +lib/codeql/xpp/elements/internal/generated/SimpleOrderElement.qll bdbd2727e9f1b15f59abe72b2ed793e995c19ae11f38358b81171ebc1d2286e2 05924c72389528727a881e594df4765cecd910753f1a14ed94d2ddf71563f534 +lib/codeql/xpp/elements/internal/generated/SimpleQualifier.qll bedea3d244167be5315dc7dc5e04087b536ceacde003e3f059961f5f878c2138 85c9e6ddf8d7f806eca905fa5610cbf079a6108e5953814848a40c1eaa407995 +lib/codeql/xpp/elements/internal/generated/SimpleQualifierInternal.qll 37681e1b410fc728328630644545b50cbcd67bb84a2347f6c834bf0ead5bfa48 60bda080232ceb871c149c548dbfa133afc091f1f1b36a464a9a7505eec3f9f6 +lib/codeql/xpp/elements/internal/generated/Statement.qll 390114da942b2e9121dc7d7269be950385e7db1402b45a736f5d840933cae8b1 62407f98f06641324a6f3cd3b21758ba382b8fda5b1dbfc50568e5f55f4928ee +lib/codeql/xpp/elements/internal/generated/StaticField.qll f80b7ea1609f2b108c127d27a1ab9e153afc18f07d0ccd8c6eac29b32a864078 378e529fb2bf3f9407aad0cf77b2e74768efd6c67ae3d53acab0c90b82af731c +lib/codeql/xpp/elements/internal/generated/StaticMethodCall.qll a25f0a4efaf0c2d675503e3d69648a8409406851876f19fe44c965549e344fc1 d687014c5fe2d008ddf367a53bf2796b689c3045597fb16252277dd6f2558c08 +lib/codeql/xpp/elements/internal/generated/StaticQualifier.qll b8300ad8014b4ee20ab859b4faa845144e8eeb853b570f1ddfdc84fb958126c9 910016437122df29c4b8464dd1161d971caf1fa48c1f372b9ede6a211277d611 +lib/codeql/xpp/elements/internal/generated/StringAttributeLiteral.qll 6f1a020f6cd3e00f1488499d46b93abb0cb7f5b83825453dd85d2cafd06e9dbc af9add672e0114477e25cf8582d1dea9ff22dc464fa35dd3fd4a762159caa7c7 +lib/codeql/xpp/elements/internal/generated/StringLengthType.qll f1757366be8e7a816379b8cf737074973829c2c3f3a4802d68dbc50f39b45a42 f5d72ffd8532e3e3c61e326a3d6b356126f74da41a5e5e03962ee0cf01f29dfc +lib/codeql/xpp/elements/internal/generated/StringLiteralExpression.qll de2896ef982e76c43aa6e88a2f2809822f76f888102d9908b6f217f69517edbc ecdc0a9ff28d3c9905f1d8cc14e23854cd3a6b725faee943891455ecff24d12e +lib/codeql/xpp/elements/internal/generated/StringType.qll 12d0e80d4eca6f1dff90349207d06108d726dd512445b1bd03e165d2661ad03d ddb578d51e9cc460b92438927f99f889ff7fa4905652b5ee3e544e8fc4dc41e4 +lib/codeql/xpp/elements/internal/generated/StringTypeInternal.qll 1460ed589f11979c2d034803b46264ef0d8e375ea09db24310412372dde3b63b 1ed9a7da3fd822bbff1f272e1e71d26dea68805ebd789bc7a0769d47a2412bcf +lib/codeql/xpp/elements/internal/generated/SubtractExpression.qll 81c6e729831d852eb06aa19c1b6da74503f1ecedcaf57561c93f3c8a97805da6 dc4f6baa94908e3cfe96694f8d8888c89a5cb03c5e08ee7a69b7cf51e663c974 +lib/codeql/xpp/elements/internal/generated/SumAggregateSelection.qll 92ca9276b57de73f0cf6d1e7e2ad42a5ecec9d71ae4c26643b5b3b1b0cf7f014 0cf74fd0f081902aad36379d10a8e08c3ab2a1a6c6251be1e404b8d470974784 +lib/codeql/xpp/elements/internal/generated/SuperCall.qll 0aeaea016f37b910f9c661352d3eefa482513ab607fbcdd65b919e450d3c0ff6 6deaea16218e3beff1c9f9f97c2b30a873c864a7cbeb109995f542717b88baa2 +lib/codeql/xpp/elements/internal/generated/SwitchCase.qll 052f113fda901605886f90b45e2993e7ee278c4005f5afe84a7a1f87aa877922 4c704e1370f217f62539a81cefacbaa7cb4d8b7730b6969a7ac7ea737979285e +lib/codeql/xpp/elements/internal/generated/SwitchStatement.qll 6bbfcd139a4f5fc3f25dcccb70a82ad7961a860a5ef7445a5f643ce1406dd572 b9922e132ee656483f77654d5a75053eceff3e6ba433a2bc3bb541d7633b6adf +lib/codeql/xpp/elements/internal/generated/SwitchStatementCaseEntry.qll 7d28ea064307e3ed9f40e96869f999f81c4f1cdff77007b0ab1d557c54f9d6b1 50ad258878c8a6251ba6e9c093e93205fdeabaa853b300657aef6237175a79a5 +lib/codeql/xpp/elements/internal/generated/Synth.qll b71dc17f63fdc4570f67581013a05553206f5ab9838dd463a5907c97c91233e8 7059ec3466825d93d0041f71ce095b5ac7379428b8bb4826f9ba8219a574083f +lib/codeql/xpp/elements/internal/generated/SynthConstructors.qll b377fdb4c6c8c31b8e791fbd2482371910a8882bb80cabbcc32aa9906290537d b377fdb4c6c8c31b8e791fbd2482371910a8882bb80cabbcc32aa9906290537d +lib/codeql/xpp/elements/internal/generated/Table.qll 1e3376ee01c0259099544568d5316cfc3a7239c2e88dccfe20025e9b5c042ce2 05d0e0c8859d6aa0c4fd0115e75a75e516dfb3d68c644ea59efcd159c59fea44 +lib/codeql/xpp/elements/internal/generated/TableFieldDeclaration.qll d7bd93bd1761fd5df2d7580c570ef5967da21d7841dc2ba73f68a853c70d87c7 de4931a5ee93bff9651fd24630df1024f3dd500c3233b58e9ee8e64fd4126a54 +lib/codeql/xpp/elements/internal/generated/TableFieldReference.qll 3c37b94cec02107719d47b057a61fb5e5aa43e8b192661a5828b1eab19bb2d23 3d3961c3264d4c261dfb76b2f67e3d3611aabb66b7acb139b729c8ca41950c5c +lib/codeql/xpp/elements/internal/generated/TableLookupExpression.qll 6dff8514c5f970d68a64021c2f220d872f96139aab7f3dda93d1c1ebbe68d08e 312c5d3cde7ad2e72a3f78854ca4ffd1ff5f4b2e523940cefadf70ed3b3a9a02 +lib/codeql/xpp/elements/internal/generated/ThrowStatement.qll 2420ec87fc4221440d46f8c7c56c3fc44d57bfed8e1d84ded761a63728755254 d3eb33b0523a236809a414224a2eb3bb4eb0738cd463612373974dae23e12e9e +lib/codeql/xpp/elements/internal/generated/TryStatement.qll 98d3f67a9d8f85ffd6b4776ee194c96cb958231ccccf183d5dd2980fb1e0aac5 147567acceeba8fa3603c4f56ce32a9fc879d2690306ed57701ce8282fe9c812 +lib/codeql/xpp/elements/internal/generated/TryStatementCatchEntry.qll 1566cd3572ea91c3a4fefb50f50159793f8b9d822de7fced0c21a69c016f973a d8898be28217655af3b69a6035cceb9920381c7ea2f11c482c5d5fbf7d30c8fa +lib/codeql/xpp/elements/internal/generated/TtsAbortStatement.qll 0208caa8bb8a40fcf637d72af6d0b72908731e226ad34eff4f5f3bfe1c7263de 9029b2232a57346d5120d365ddd86dcd8dbef038c2fb61124ae99ace2fd5e2a7 +lib/codeql/xpp/elements/internal/generated/TtsBeginStatement.qll 9e601d0ec144225e4a544a0cd199b514e83c71c2dd4108256239154cfdcde054 f85030f5745133bd7b63ebebe2fd69163a7ade243c5409c8cee7bfdcc6a9aa29 +lib/codeql/xpp/elements/internal/generated/TtsEndStatement.qll 94fa44b175ef5fc48dfdbf6e8ceba65b7c139659d62c3bbbcc11c317cce87c20 72b59a7460d4281a1fe58ddba283646b743c4ca0ced06f5d056ee9ab0a180f94 +lib/codeql/xpp/elements/internal/generated/TtsStatement.qll 8926aa2cafa4bbf8cb3981778df19c28f843d49bd763b86f06b7d1adde510e3f a9f334f7e4d594988729328151dfea2fc481c612eff2b27ceaee2ee20578aa41 +lib/codeql/xpp/elements/internal/generated/UnaryExpression.qll 0045d3cb40c7325995522a0a56907cdc2b63105712b0d570c8758a508e22a6d6 3cc1d409c1ef9b5d3c707087a62173023917aa5b880ee8e90693b4a431ae4974 +lib/codeql/xpp/elements/internal/generated/UnaryMinusExpression.qll 22e277aaa6e7273185d1a97df3fee3eed3a28142272990a7116161559ed1f26a e002de906f30a884e8d9af1142df9173adb5153e9e8901a1aa80c0c6501e7d4e +lib/codeql/xpp/elements/internal/generated/UncheckedStatement.qll dfb7aadb22c62520a0ad5135dc510a74dc8bee105c94d57c609fd2e0ee65d393 9afd392a5f7329adc147975aef8db7aeaa8c4ee8f17e2ab7afd5d67eb474d7d5 +lib/codeql/xpp/elements/internal/generated/UnspecifiedElement.qll 0b4e75150c69504222225c66bed178dfc60f62e82aadb1c34e7b19c0ac0678f5 8c4b11eb5eccbd51ddccbc9cc87a0402cd2b783aa79451f1759c37e850c3d623 +lib/codeql/xpp/elements/internal/generated/UpdateStatement.qll 4b3c2d37eeb164f28b9c8b92df03fa2f0cc531325c5649dae09ae1d3f4953c7e a152cada2994abc9695ee01fdf978694628cb4947a172f0c53fc583187a5fb25 +lib/codeql/xpp/elements/internal/generated/UsingStatement.qll 35e2e7c6062ac33396168ac9cde9268380a08d0843632acb578689a2647df10a bd09985feb05b77de00efd348829b5a1428d8463fbf2fb0cf7b97c63c2e90a60 +lib/codeql/xpp/elements/internal/generated/ValidTimeState.qll 9e8c591dbff246a4f62b63e7f6aa9384ef402d5409dbb7173a0a6d38bc3832a8 30b3f81bfeaee8e95a63f757947dd593aa5df8b47d0f97981e2ea2e382ee0326 +lib/codeql/xpp/elements/internal/generated/ValidTimeStateDate.qll 13baed14f37795076796eb2a19725f94c0b347e3048147f8e36d994ee242a304 88c15e1369b16533643c7cd6b60cd1834f4dc0c74e61e1c834ae145dab177756 +lib/codeql/xpp/elements/internal/generated/ValidTimeStateRange.qll 62a01a325c0c5c8e1cbeabab5eee83beb06d4b364a9da08b82d6a16dddaabd77 bf8dc20cd5c4ef423ef58c105df2bc1615c7a49aa8e704f606b45246a5f6caac +lib/codeql/xpp/elements/internal/generated/VarType.qll 073ea80c072d68eac5b0954bc14fb435443e327ae2f42adeba59bc4c5679a277 1390230f3145731955a80b7570d6225d0ea2abb037fe0a88110a8776ab799739 +lib/codeql/xpp/elements/internal/generated/VariableDeclaration.qll 50726ce5adcf3d5b1f3316d0722f8efbdfbfc215126893290bba392b37da162a 940e868f7f3e2ebea766e26b0a7dbb75d385d35dd17ec82c2239262a96451d61 +lib/codeql/xpp/elements/internal/generated/VariableDeclarationInternal.qll f88e102c456bba7bde9beb6edfdfcefee962bde149a0567f2d6066af37d0f83d e8ffbdca4682684a7e869dd1fd3382d68e604c889e5e00770b31be5ad6476e6f +lib/codeql/xpp/elements/internal/generated/VoidType.qll f453472498be3527c30f190589e6915eaba5465414ec1c90a4317d7e7d1ed09d 19bf9d0a3900768f69ab9e7d6e3451caa3ecaee7fdd6e5327a116a93f51d9305 +lib/codeql/xpp/elements/internal/generated/WhileStatement.qll 98ffe155f2d02b2a7b6f3ee2cf512fef84bfc01cd631ae5e073168fa6013d22f 9436e341ecae7e8ba77054746ac36ae03a66aa78aa4c58a3f8cb9da4ae150e11 +lib/codeql/xpp/elements/internal/generated/XppTuple.qll 472d1e0944dd1b1231e843476162aff69f92b7f93f2f53c063b46d86c4d2bb8d 7b2370d27c48e334b144dec5d51e59649c9ee5c6975a482cf71351347e09719e +lib/codeql/xpp/elements/internal/generated/XppType.qll fd96e9da05bbe8586cd834da08599886d2d0a2e43800402606af540f36742c17 4b5bd76207fd37efd3ac99e5e30684774abe96e2661209aa12a49a87f4c0784c +lib/codeql/xpp/elements/internal/generated/XppTypeCompilationUnit.qll 761216a7c949cf9544fd16bda4f0345b789d07a52df35940cbd98a1412bc1882 161447d4aa77395b1fce20f699ea9fb71ae91397e881450d055d43f7afacd170 +lib/codeql/xpp/elements.qll 075fc23da5b920bcabe99643f231df49286456f6bfb3e71b6b01f12a9c8fa7c4 075fc23da5b920bcabe99643f231df49286456f6bfb3e71b6b01f12a9c8fa7c4 diff --git a/xpp/ql/.gitattributes b/xpp/ql/.gitattributes new file mode 100644 index 000000000000..7e1f08c3d208 --- /dev/null +++ b/xpp/ql/.gitattributes @@ -0,0 +1,1219 @@ +/.generated.list linguist-generated +/.gitattributes linguist-generated +/build/extractor-tests/AddExpression/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/AllFieldsSelection/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/AndExpression/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/AnyType/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/ArraySpecification/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/AsClrExpression/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/AsExpression/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/AssignDecrementStatement/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/AssignDivideStatement/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/AssignEqualStatement/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/AssignIncrementStatement/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/AssignMultipleFieldStatement/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/AssignMultiplyStatement/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/AssignPostDecrementStatement/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/AssignPostIncrementStatement/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/AssignPreDecrementStatement/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/AssignPreIncrementStatement/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/AssignmentEventHandlerClr/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/AssignmentEventHandlerInstance/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/AssignmentEventHandlerStaticInternal/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/Attribute/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/AttributeExpression/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/AttributeList/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/AttributeNamedParameterEntry/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/AvgAggregateSelection/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/BooleanAttributeLiteral/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/BooleanLiteralExpression/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/BooleanType/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/BreakStatement/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/BreakpointStatement/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/CaseDefault/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/CaseValues/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/CatchAllValues/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/CatchExpression/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/CatchUpdateConflict/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/ChangeCompanyStatement/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/Class/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/ClassAccessModifier/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/ClrEnumerationLiteralExpression/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/ClrType/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/Comment/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/CompilationUnitRegionEntry/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/CompoundStatement/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/ConditionalExpression/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/ContainerAttributeLiteral/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/ContainerLiteralExpression/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/ContainerType/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/ContinueStatement/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/CountAggregateSelection/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/CrossCompanyAll/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/CrossCompanyContainer/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/DateAttributeLiteral/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/DateLiteralExpression/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/DateTimeAttributeLiteral/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/DateTimeLiteralExpression/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/DateTimeType/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/DateType/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/DblAttributeLiteral/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/DblType/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/Delegate/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/DeleteStatement/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/DivideExpression/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/DoWhileStatement/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/EmptyExpression/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/EmptyStatement/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/EnumAttributeLiteral/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/EnumerationLiteralExpression/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/EnumerationType/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/EqualExpression/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/EvaluationActualParameterEntry/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/ExplicitSelection/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/ExpressionCompilationUnit/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/ExpressionQualifier/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/ExpressionStatement/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/FieldAssignment/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/FieldDeclarationInternal/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/FieldExpressionInternal/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/FieldSelection/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/File/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/FindStatement/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/FlushStatement/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/ForDeclarationAssign/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/ForFieldAssign/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/ForFieldDecrementAssign/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/ForFieldIncrementAssign/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/ForFieldPostDecrement/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/ForFieldPostIncrement/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/ForFieldPreDecrement/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/ForFieldPreIncrement/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/ForStatement/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/FormControl/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/FormDataField/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/FormDataSource/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/FormElementType/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/FormModelElement/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/FunctionCall/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/FunctionDeclaration/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/GlobalOrderElement/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/GreaterThanExpression/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/GreaterThanOrEqualExpression/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/GuidAttributeLiteral/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/GuidType/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/IfStatement/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/IfThenElseStatement/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/ImplicitSelection/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/InExpression/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/InsertFieldSpecification/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/InsertStatement/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/Int64AttributeLiteral/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/Int64LiteralExpression/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/Int64Type/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/IntAttributeLiteral/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/IntLiteralExpression/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/IntType/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/IntegerDivideExpression/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/Interface/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/Intrinsic/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/IntrinsicAttributeLiteral/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/IsClrExpression/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/IsExpression/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/JoinSpecification/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/LessThanExpression/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/LessThanOrEqualExpression/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/LikeExpression/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/LocalDeclarationsStatement/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/MaxAggregateSelection/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/Method/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/MinAggregateSelection/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/ModExpression/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/ModelElementUsingEntry/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/Modifier/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/MoveCursorStatement/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/MultiplyExpression/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/NamedFieldReference/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/NamedTypeInternal/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/NewCall/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/NewClrArrayExpression/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/NewClrCall/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/NextExpression/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/NotEqualExpression/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/NotExpression/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/NullLiteralExpression/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/NumberedFieldReference/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/OrExpression/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/ParameterDeclaration/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/PhysicalAndExpression/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/PhysicalNotExpression/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/PhysicalOrExpression/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/PhysicalXorExpression/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/Placeholder/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/PrintStatement/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/ProvidedType/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/ProvidedTypeStaticCall/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/QualifiedCall/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/QualifiedField/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/QualifiedInstanceName/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/QualifiedNumberedField/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/QualifiedStaticCall/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/QualifiedStaticField/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/QualifiedStaticFieldExpression/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/Query/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/QueryDataSource/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/QueryDataSourceHaving/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/QueryDataSourceRange/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/QueryDataSourceRelation/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/QueryModelElement/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/RealLiteralExpression/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/RetryStatement/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/ReturnStatement/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/SearchStatement/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/ShiftLeftExpression/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/ShiftRightExpression/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/SimpleField/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/SimpleInstanceName/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/SimpleOrderElement/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/SimpleQualifierInternal/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/StaticField/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/StaticMethodCall/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/StaticQualifier/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/StringAttributeLiteral/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/StringLengthType/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/StringLiteralExpression/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/StringTypeInternal/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/SubtractExpression/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/SumAggregateSelection/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/SuperCall/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/SwitchCase/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/SwitchStatement/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/SwitchStatementCaseEntry/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/Table/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/TableFieldDeclaration/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/TableLookupExpression/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/ThrowStatement/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/TryStatement/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/TryStatementCatchEntry/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/TtsAbortStatement/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/TtsBeginStatement/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/TtsEndStatement/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/UnaryMinusExpression/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/UncheckedStatement/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/UpdateStatement/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/UsingStatement/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/ValidTimeStateDate/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/ValidTimeStateRange/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/VarType/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/VariableDeclarationInternal/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/VoidType/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/WhileStatement/MISSING_SOURCE.txt linguist-generated +/build/extractor-tests/XppTypeCompilationUnit/MISSING_SOURCE.txt linguist-generated +/lib/codeql/xpp/elements/AddExpression.qll linguist-generated +/lib/codeql/xpp/elements/AggregateSelection.qll linguist-generated +/lib/codeql/xpp/elements/AllFieldsSelection.qll linguist-generated +/lib/codeql/xpp/elements/AndExpression.qll linguist-generated +/lib/codeql/xpp/elements/AnyType.qll linguist-generated +/lib/codeql/xpp/elements/ArraySpecification.qll linguist-generated +/lib/codeql/xpp/elements/AsClrExpression.qll linguist-generated +/lib/codeql/xpp/elements/AsExpression.qll linguist-generated +/lib/codeql/xpp/elements/AssignDecrementStatement.qll linguist-generated +/lib/codeql/xpp/elements/AssignDivideStatement.qll linguist-generated +/lib/codeql/xpp/elements/AssignEqualStatement.qll linguist-generated +/lib/codeql/xpp/elements/AssignIncrementStatement.qll linguist-generated +/lib/codeql/xpp/elements/AssignMultipleFieldStatement.qll linguist-generated +/lib/codeql/xpp/elements/AssignMultiplyStatement.qll linguist-generated +/lib/codeql/xpp/elements/AssignPostDecrementStatement.qll linguist-generated +/lib/codeql/xpp/elements/AssignPostIncrementStatement.qll linguist-generated +/lib/codeql/xpp/elements/AssignPreDecrementStatement.qll linguist-generated +/lib/codeql/xpp/elements/AssignPreIncrementStatement.qll linguist-generated +/lib/codeql/xpp/elements/AssignmentBinary.qll linguist-generated +/lib/codeql/xpp/elements/AssignmentEventHandlerBase.qll linguist-generated +/lib/codeql/xpp/elements/AssignmentEventHandlerClr.qll linguist-generated +/lib/codeql/xpp/elements/AssignmentEventHandlerInstance.qll linguist-generated +/lib/codeql/xpp/elements/AssignmentEventHandlerStatic.qll linguist-generated +/lib/codeql/xpp/elements/AssignmentEventHandlerStaticInternal.qll linguist-generated +/lib/codeql/xpp/elements/AssignmentSingleField.qll linguist-generated +/lib/codeql/xpp/elements/AssignmentStatement.qll linguist-generated +/lib/codeql/xpp/elements/Ast.qll linguist-generated +/lib/codeql/xpp/elements/Attribute.qll linguist-generated +/lib/codeql/xpp/elements/AttributeExpression.qll linguist-generated +/lib/codeql/xpp/elements/AttributeList.qll linguist-generated +/lib/codeql/xpp/elements/AttributeLiteral.qll linguist-generated +/lib/codeql/xpp/elements/AttributeNamedParameterEntry.qll linguist-generated +/lib/codeql/xpp/elements/AvgAggregateSelection.qll linguist-generated +/lib/codeql/xpp/elements/BinaryExpression.qll linguist-generated +/lib/codeql/xpp/elements/BooleanAttributeLiteral.qll linguist-generated +/lib/codeql/xpp/elements/BooleanLiteralExpression.qll linguist-generated +/lib/codeql/xpp/elements/BooleanType.qll linguist-generated +/lib/codeql/xpp/elements/BreakStatement.qll linguist-generated +/lib/codeql/xpp/elements/BreakpointStatement.qll linguist-generated +/lib/codeql/xpp/elements/Case.qll linguist-generated +/lib/codeql/xpp/elements/CaseDefault.qll linguist-generated +/lib/codeql/xpp/elements/CaseValues.qll linguist-generated +/lib/codeql/xpp/elements/Catch.qll linguist-generated +/lib/codeql/xpp/elements/CatchAllValues.qll linguist-generated +/lib/codeql/xpp/elements/CatchExpression.qll linguist-generated +/lib/codeql/xpp/elements/CatchUpdateConflict.qll linguist-generated +/lib/codeql/xpp/elements/ChangeCompanyStatement.qll linguist-generated +/lib/codeql/xpp/elements/ChangeStatement.qll linguist-generated +/lib/codeql/xpp/elements/Class.qll linguist-generated +/lib/codeql/xpp/elements/ClassAccessModifier.qll linguist-generated +/lib/codeql/xpp/elements/ClassOrInterface.qll linguist-generated +/lib/codeql/xpp/elements/ClrEnumerationLiteralExpression.qll linguist-generated +/lib/codeql/xpp/elements/ClrType.qll linguist-generated +/lib/codeql/xpp/elements/Comment.qll linguist-generated +/lib/codeql/xpp/elements/CompilationUnit.qll linguist-generated +/lib/codeql/xpp/elements/CompilationUnitRegionEntry.qll linguist-generated +/lib/codeql/xpp/elements/CompoundStatement.qll linguist-generated +/lib/codeql/xpp/elements/ConditionalExpression.qll linguist-generated +/lib/codeql/xpp/elements/ContainerAttributeLiteral.qll linguist-generated +/lib/codeql/xpp/elements/ContainerLiteralExpression.qll linguist-generated +/lib/codeql/xpp/elements/ContainerType.qll linguist-generated +/lib/codeql/xpp/elements/ContinueStatement.qll linguist-generated +/lib/codeql/xpp/elements/CountAggregateSelection.qll linguist-generated +/lib/codeql/xpp/elements/CrossCompany.qll linguist-generated +/lib/codeql/xpp/elements/CrossCompanyAll.qll linguist-generated +/lib/codeql/xpp/elements/CrossCompanyContainer.qll linguist-generated +/lib/codeql/xpp/elements/DateAttributeLiteral.qll linguist-generated +/lib/codeql/xpp/elements/DateLiteralExpression.qll linguist-generated +/lib/codeql/xpp/elements/DateTimeAttributeLiteral.qll linguist-generated +/lib/codeql/xpp/elements/DateTimeLiteralExpression.qll linguist-generated +/lib/codeql/xpp/elements/DateTimeType.qll linguist-generated +/lib/codeql/xpp/elements/DateType.qll linguist-generated +/lib/codeql/xpp/elements/DblAttributeLiteral.qll linguist-generated +/lib/codeql/xpp/elements/DblType.qll linguist-generated +/lib/codeql/xpp/elements/Declaration.qll linguist-generated +/lib/codeql/xpp/elements/DefaultTypeAttributeLiteral.qll linguist-generated +/lib/codeql/xpp/elements/DefaultTypeLiteralExpression.qll linguist-generated +/lib/codeql/xpp/elements/Delegate.qll linguist-generated +/lib/codeql/xpp/elements/DeleteStatement.qll linguist-generated +/lib/codeql/xpp/elements/DivideExpression.qll linguist-generated +/lib/codeql/xpp/elements/DoWhileStatement.qll linguist-generated +/lib/codeql/xpp/elements/Element.qll linguist-generated +/lib/codeql/xpp/elements/EmptyExpression.qll linguist-generated +/lib/codeql/xpp/elements/EmptyStatement.qll linguist-generated +/lib/codeql/xpp/elements/EnumAttributeLiteral.qll linguist-generated +/lib/codeql/xpp/elements/EnumerationLiteralExpression.qll linguist-generated +/lib/codeql/xpp/elements/EnumerationType.qll linguist-generated +/lib/codeql/xpp/elements/EqualExpression.qll linguist-generated +/lib/codeql/xpp/elements/ErrorElement.qll linguist-generated +/lib/codeql/xpp/elements/Evaluation.qll linguist-generated +/lib/codeql/xpp/elements/EvaluationActualParameterEntry.qll linguist-generated +/lib/codeql/xpp/elements/ExplicitSelection.qll linguist-generated +/lib/codeql/xpp/elements/Expression.qll linguist-generated +/lib/codeql/xpp/elements/ExpressionCompilationUnit.qll linguist-generated +/lib/codeql/xpp/elements/ExpressionQualifier.qll linguist-generated +/lib/codeql/xpp/elements/ExpressionStatement.qll linguist-generated +/lib/codeql/xpp/elements/FieldAssignment.qll linguist-generated +/lib/codeql/xpp/elements/FieldDeclaration.qll linguist-generated +/lib/codeql/xpp/elements/FieldDeclarationInternal.qll linguist-generated +/lib/codeql/xpp/elements/FieldExpression.qll linguist-generated +/lib/codeql/xpp/elements/FieldExpressionInternal.qll linguist-generated +/lib/codeql/xpp/elements/FieldSelection.qll linguist-generated +/lib/codeql/xpp/elements/FieldSpecification.qll linguist-generated +/lib/codeql/xpp/elements/File.qll linguist-generated +/lib/codeql/xpp/elements/FindStatement.qll linguist-generated +/lib/codeql/xpp/elements/FlushStatement.qll linguist-generated +/lib/codeql/xpp/elements/ForAssign.qll linguist-generated +/lib/codeql/xpp/elements/ForDeclarationAssign.qll linguist-generated +/lib/codeql/xpp/elements/ForExpressionAssign.qll linguist-generated +/lib/codeql/xpp/elements/ForFieldAssign.qll linguist-generated +/lib/codeql/xpp/elements/ForFieldDecrementAssign.qll linguist-generated +/lib/codeql/xpp/elements/ForFieldIncrementAssign.qll linguist-generated +/lib/codeql/xpp/elements/ForFieldPostDecrement.qll linguist-generated +/lib/codeql/xpp/elements/ForFieldPostIncrement.qll linguist-generated +/lib/codeql/xpp/elements/ForFieldPreDecrement.qll linguist-generated +/lib/codeql/xpp/elements/ForFieldPreIncrement.qll linguist-generated +/lib/codeql/xpp/elements/ForStatement.qll linguist-generated +/lib/codeql/xpp/elements/FormControl.qll linguist-generated +/lib/codeql/xpp/elements/FormDataField.qll linguist-generated +/lib/codeql/xpp/elements/FormDataSource.qll linguist-generated +/lib/codeql/xpp/elements/FormElementType.qll linguist-generated +/lib/codeql/xpp/elements/FormModelElement.qll linguist-generated +/lib/codeql/xpp/elements/FormNestedElement.qll linguist-generated +/lib/codeql/xpp/elements/FunctionCall.qll linguist-generated +/lib/codeql/xpp/elements/FunctionDeclaration.qll linguist-generated +/lib/codeql/xpp/elements/GenericEvaluation.qll linguist-generated +/lib/codeql/xpp/elements/GenericXppType.qll linguist-generated +/lib/codeql/xpp/elements/GlobalOrderElement.qll linguist-generated +/lib/codeql/xpp/elements/GreaterThanExpression.qll linguist-generated +/lib/codeql/xpp/elements/GreaterThanOrEqualExpression.qll linguist-generated +/lib/codeql/xpp/elements/GuidAttributeLiteral.qll linguist-generated +/lib/codeql/xpp/elements/GuidType.qll linguist-generated +/lib/codeql/xpp/elements/IfStatement.qll linguist-generated +/lib/codeql/xpp/elements/IfThenElseStatement.qll linguist-generated +/lib/codeql/xpp/elements/ImplicitSelection.qll linguist-generated +/lib/codeql/xpp/elements/InExpression.qll linguist-generated +/lib/codeql/xpp/elements/InsertFieldSpecification.qll linguist-generated +/lib/codeql/xpp/elements/InsertStatement.qll linguist-generated +/lib/codeql/xpp/elements/InstanceName.qll linguist-generated +/lib/codeql/xpp/elements/Int64AttributeLiteral.qll linguist-generated +/lib/codeql/xpp/elements/Int64LiteralExpression.qll linguist-generated +/lib/codeql/xpp/elements/Int64Type.qll linguist-generated +/lib/codeql/xpp/elements/IntAttributeLiteral.qll linguist-generated +/lib/codeql/xpp/elements/IntLiteralExpression.qll linguist-generated +/lib/codeql/xpp/elements/IntType.qll linguist-generated +/lib/codeql/xpp/elements/IntegerDivideExpression.qll linguist-generated +/lib/codeql/xpp/elements/Interface.qll linguist-generated +/lib/codeql/xpp/elements/Intrinsic.qll linguist-generated +/lib/codeql/xpp/elements/IntrinsicAttributeLiteral.qll linguist-generated +/lib/codeql/xpp/elements/IsAsExpression.qll linguist-generated +/lib/codeql/xpp/elements/IsClrExpression.qll linguist-generated +/lib/codeql/xpp/elements/IsExpression.qll linguist-generated +/lib/codeql/xpp/elements/JoinSpecification.qll linguist-generated +/lib/codeql/xpp/elements/LessThanExpression.qll linguist-generated +/lib/codeql/xpp/elements/LessThanOrEqualExpression.qll linguist-generated +/lib/codeql/xpp/elements/LikeExpression.qll linguist-generated +/lib/codeql/xpp/elements/LiteralExpression.qll linguist-generated +/lib/codeql/xpp/elements/LocalDeclaration.qll linguist-generated +/lib/codeql/xpp/elements/LocalDeclarationsStatement.qll linguist-generated +/lib/codeql/xpp/elements/Locatable.qll linguist-generated +/lib/codeql/xpp/elements/Location.qll linguist-generated +/lib/codeql/xpp/elements/MaxAggregateSelection.qll linguist-generated +/lib/codeql/xpp/elements/Method.qll linguist-generated +/lib/codeql/xpp/elements/MethodOrDelegate.qll linguist-generated +/lib/codeql/xpp/elements/MinAggregateSelection.qll linguist-generated +/lib/codeql/xpp/elements/ModExpression.qll linguist-generated +/lib/codeql/xpp/elements/ModelElement.qll linguist-generated +/lib/codeql/xpp/elements/ModelElementUsingEntry.qll linguist-generated +/lib/codeql/xpp/elements/Modifier.qll linguist-generated +/lib/codeql/xpp/elements/MoveCursorStatement.qll linguist-generated +/lib/codeql/xpp/elements/MultiplyExpression.qll linguist-generated +/lib/codeql/xpp/elements/NamedFieldReference.qll linguist-generated +/lib/codeql/xpp/elements/NamedType.qll linguist-generated +/lib/codeql/xpp/elements/NamedTypeInternal.qll linguist-generated +/lib/codeql/xpp/elements/NewCall.qll linguist-generated +/lib/codeql/xpp/elements/NewClrArrayExpression.qll linguist-generated +/lib/codeql/xpp/elements/NewClrCall.qll linguist-generated +/lib/codeql/xpp/elements/NextExpression.qll linguist-generated +/lib/codeql/xpp/elements/NotEqualExpression.qll linguist-generated +/lib/codeql/xpp/elements/NotExpression.qll linguist-generated +/lib/codeql/xpp/elements/NullLiteralExpression.qll linguist-generated +/lib/codeql/xpp/elements/NumberedFieldReference.qll linguist-generated +/lib/codeql/xpp/elements/OrExpression.qll linguist-generated +/lib/codeql/xpp/elements/OrderElement.qll linguist-generated +/lib/codeql/xpp/elements/ParameterDeclaration.qll linguist-generated +/lib/codeql/xpp/elements/PhysicalAndExpression.qll linguist-generated +/lib/codeql/xpp/elements/PhysicalNotExpression.qll linguist-generated +/lib/codeql/xpp/elements/PhysicalOrExpression.qll linguist-generated +/lib/codeql/xpp/elements/PhysicalXorExpression.qll linguist-generated +/lib/codeql/xpp/elements/Placeholder.qll linguist-generated +/lib/codeql/xpp/elements/PrintStatement.qll linguist-generated +/lib/codeql/xpp/elements/ProvidedType.qll linguist-generated +/lib/codeql/xpp/elements/ProvidedTypeStaticCall.qll linguist-generated +/lib/codeql/xpp/elements/QualifiedCall.qll linguist-generated +/lib/codeql/xpp/elements/QualifiedField.qll linguist-generated +/lib/codeql/xpp/elements/QualifiedInstanceName.qll linguist-generated +/lib/codeql/xpp/elements/QualifiedNumberedField.qll linguist-generated +/lib/codeql/xpp/elements/QualifiedStaticCall.qll linguist-generated +/lib/codeql/xpp/elements/QualifiedStaticField.qll linguist-generated +/lib/codeql/xpp/elements/QualifiedStaticFieldExpression.qll linguist-generated +/lib/codeql/xpp/elements/Qualifier.qll linguist-generated +/lib/codeql/xpp/elements/Query.qll linguist-generated +/lib/codeql/xpp/elements/QueryDataSource.qll linguist-generated +/lib/codeql/xpp/elements/QueryDataSourceHaving.qll linguist-generated +/lib/codeql/xpp/elements/QueryDataSourceRange.qll linguist-generated +/lib/codeql/xpp/elements/QueryDataSourceRelation.qll linguist-generated +/lib/codeql/xpp/elements/QueryModelElement.qll linguist-generated +/lib/codeql/xpp/elements/RealLiteralExpression.qll linguist-generated +/lib/codeql/xpp/elements/RelationalExpression.qll linguist-generated +/lib/codeql/xpp/elements/RetryStatement.qll linguist-generated +/lib/codeql/xpp/elements/ReturnStatement.qll linguist-generated +/lib/codeql/xpp/elements/SearchStatement.qll linguist-generated +/lib/codeql/xpp/elements/Selection.qll linguist-generated +/lib/codeql/xpp/elements/SelectionField.qll linguist-generated +/lib/codeql/xpp/elements/ShiftLeftExpression.qll linguist-generated +/lib/codeql/xpp/elements/ShiftRightExpression.qll linguist-generated +/lib/codeql/xpp/elements/SimpleField.qll linguist-generated +/lib/codeql/xpp/elements/SimpleInstanceName.qll linguist-generated +/lib/codeql/xpp/elements/SimpleOrderElement.qll linguist-generated +/lib/codeql/xpp/elements/SimpleQualifier.qll linguist-generated +/lib/codeql/xpp/elements/SimpleQualifierInternal.qll linguist-generated +/lib/codeql/xpp/elements/Statement.qll linguist-generated +/lib/codeql/xpp/elements/StaticField.qll linguist-generated +/lib/codeql/xpp/elements/StaticMethodCall.qll linguist-generated +/lib/codeql/xpp/elements/StaticQualifier.qll linguist-generated +/lib/codeql/xpp/elements/StringAttributeLiteral.qll linguist-generated +/lib/codeql/xpp/elements/StringLengthType.qll linguist-generated +/lib/codeql/xpp/elements/StringLiteralExpression.qll linguist-generated +/lib/codeql/xpp/elements/StringType.qll linguist-generated +/lib/codeql/xpp/elements/StringTypeInternal.qll linguist-generated +/lib/codeql/xpp/elements/SubtractExpression.qll linguist-generated +/lib/codeql/xpp/elements/SumAggregateSelection.qll linguist-generated +/lib/codeql/xpp/elements/SuperCall.qll linguist-generated +/lib/codeql/xpp/elements/SwitchCase.qll linguist-generated +/lib/codeql/xpp/elements/SwitchStatement.qll linguist-generated +/lib/codeql/xpp/elements/SwitchStatementCaseEntry.qll linguist-generated +/lib/codeql/xpp/elements/Table.qll linguist-generated +/lib/codeql/xpp/elements/TableFieldDeclaration.qll linguist-generated +/lib/codeql/xpp/elements/TableFieldReference.qll linguist-generated +/lib/codeql/xpp/elements/TableLookupExpression.qll linguist-generated +/lib/codeql/xpp/elements/ThrowStatement.qll linguist-generated +/lib/codeql/xpp/elements/TryStatement.qll linguist-generated +/lib/codeql/xpp/elements/TryStatementCatchEntry.qll linguist-generated +/lib/codeql/xpp/elements/TtsAbortStatement.qll linguist-generated +/lib/codeql/xpp/elements/TtsBeginStatement.qll linguist-generated +/lib/codeql/xpp/elements/TtsEndStatement.qll linguist-generated +/lib/codeql/xpp/elements/TtsStatement.qll linguist-generated +/lib/codeql/xpp/elements/UnaryExpression.qll linguist-generated +/lib/codeql/xpp/elements/UnaryMinusExpression.qll linguist-generated +/lib/codeql/xpp/elements/UncheckedStatement.qll linguist-generated +/lib/codeql/xpp/elements/UnspecifiedElement.qll linguist-generated +/lib/codeql/xpp/elements/UpdateStatement.qll linguist-generated +/lib/codeql/xpp/elements/UsingStatement.qll linguist-generated +/lib/codeql/xpp/elements/ValidTimeState.qll linguist-generated +/lib/codeql/xpp/elements/ValidTimeStateDate.qll linguist-generated +/lib/codeql/xpp/elements/ValidTimeStateRange.qll linguist-generated +/lib/codeql/xpp/elements/VarType.qll linguist-generated +/lib/codeql/xpp/elements/VariableDeclaration.qll linguist-generated +/lib/codeql/xpp/elements/VariableDeclarationInternal.qll linguist-generated +/lib/codeql/xpp/elements/VoidType.qll linguist-generated +/lib/codeql/xpp/elements/WhileStatement.qll linguist-generated +/lib/codeql/xpp/elements/XppTuple.qll linguist-generated +/lib/codeql/xpp/elements/XppType.qll linguist-generated +/lib/codeql/xpp/elements/XppTypeCompilationUnit.qll linguist-generated +/lib/codeql/xpp/elements/internal/AddExpressionConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/AddExpressionImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/AggregateSelectionImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/AllFieldsSelectionConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/AllFieldsSelectionImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/AndExpressionConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/AndExpressionImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/AnyTypeConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/AnyTypeImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/ArraySpecificationConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/ArraySpecificationImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/AsClrExpressionConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/AsClrExpressionImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/AsExpressionConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/AsExpressionImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/AssignDecrementStatementConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/AssignDecrementStatementImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/AssignDivideStatementConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/AssignDivideStatementImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/AssignEqualStatementConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/AssignEqualStatementImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/AssignIncrementStatementConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/AssignIncrementStatementImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/AssignMultipleFieldStatementConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/AssignMultipleFieldStatementImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/AssignMultiplyStatementConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/AssignMultiplyStatementImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/AssignPostDecrementStatementConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/AssignPostDecrementStatementImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/AssignPostIncrementStatementConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/AssignPostIncrementStatementImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/AssignPreDecrementStatementConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/AssignPreDecrementStatementImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/AssignPreIncrementStatementConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/AssignPreIncrementStatementImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/AssignmentBinaryImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/AssignmentEventHandlerBaseImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/AssignmentEventHandlerClrConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/AssignmentEventHandlerClrImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/AssignmentEventHandlerInstanceConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/AssignmentEventHandlerInstanceImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/AssignmentEventHandlerStaticImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/AssignmentEventHandlerStaticInternalConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/AssignmentEventHandlerStaticInternalImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/AssignmentSingleFieldImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/AssignmentStatementImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/AstImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/AttributeConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/AttributeExpressionConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/AttributeExpressionImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/AttributeImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/AttributeListConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/AttributeListImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/AttributeLiteralImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/AttributeNamedParameterEntryConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/AttributeNamedParameterEntryImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/AvgAggregateSelectionConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/AvgAggregateSelectionImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/BinaryExpressionImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/BooleanAttributeLiteralConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/BooleanAttributeLiteralImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/BooleanLiteralExpressionConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/BooleanLiteralExpressionImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/BooleanTypeConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/BooleanTypeImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/BreakStatementConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/BreakStatementImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/BreakpointStatementConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/BreakpointStatementImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/CaseDefaultConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/CaseDefaultImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/CaseImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/CaseValuesConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/CaseValuesImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/CatchAllValuesConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/CatchAllValuesImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/CatchExpressionConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/CatchExpressionImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/CatchImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/CatchUpdateConflictConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/CatchUpdateConflictImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/ChangeCompanyStatementConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/ChangeCompanyStatementImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/ChangeStatementImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/ClassAccessModifierConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/ClassAccessModifierImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/ClassConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/ClassImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/ClassOrInterfaceImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/ClrEnumerationLiteralExpressionConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/ClrEnumerationLiteralExpressionImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/ClrTypeConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/ClrTypeImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/CommentConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/CommentImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/CompilationUnitImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/CompilationUnitRegionEntryConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/CompilationUnitRegionEntryImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/CompoundStatementConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/CompoundStatementImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/ConditionalExpressionConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/ConditionalExpressionImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/ContainerAttributeLiteralConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/ContainerAttributeLiteralImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/ContainerLiteralExpressionConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/ContainerLiteralExpressionImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/ContainerTypeConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/ContainerTypeImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/ContinueStatementConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/ContinueStatementImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/CountAggregateSelectionConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/CountAggregateSelectionImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/CrossCompanyAllConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/CrossCompanyAllImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/CrossCompanyContainerConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/CrossCompanyContainerImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/CrossCompanyImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/DateAttributeLiteralConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/DateAttributeLiteralImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/DateLiteralExpressionConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/DateLiteralExpressionImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/DateTimeAttributeLiteralConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/DateTimeAttributeLiteralImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/DateTimeLiteralExpressionConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/DateTimeLiteralExpressionImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/DateTimeTypeConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/DateTimeTypeImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/DateTypeConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/DateTypeImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/DblAttributeLiteralConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/DblAttributeLiteralImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/DblTypeConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/DblTypeImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/DeclarationImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/DefaultTypeAttributeLiteralImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/DefaultTypeLiteralExpressionImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/DelegateConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/DelegateImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/DeleteStatementConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/DeleteStatementImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/DivideExpressionConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/DivideExpressionImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/DoWhileStatementConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/DoWhileStatementImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/EmptyExpressionConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/EmptyExpressionImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/EmptyStatementConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/EmptyStatementImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/EnumAttributeLiteralConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/EnumAttributeLiteralImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/EnumerationLiteralExpressionConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/EnumerationLiteralExpressionImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/EnumerationTypeConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/EnumerationTypeImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/EqualExpressionConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/EqualExpressionImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/ErrorElementImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/EvaluationActualParameterEntryConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/EvaluationActualParameterEntryImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/EvaluationImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/ExplicitSelectionConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/ExplicitSelectionImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/ExpressionCompilationUnitConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/ExpressionCompilationUnitImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/ExpressionImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/ExpressionQualifierConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/ExpressionQualifierImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/ExpressionStatementConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/ExpressionStatementImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/FieldAssignmentConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/FieldAssignmentImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/FieldDeclarationImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/FieldDeclarationInternalConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/FieldDeclarationInternalImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/FieldExpressionImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/FieldExpressionInternalConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/FieldExpressionInternalImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/FieldSelectionConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/FieldSelectionImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/FieldSpecificationImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/FileConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/FileImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/FindStatementConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/FindStatementImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/FlushStatementConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/FlushStatementImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/ForAssignImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/ForDeclarationAssignConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/ForDeclarationAssignImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/ForExpressionAssignImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/ForFieldAssignConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/ForFieldAssignImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/ForFieldDecrementAssignConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/ForFieldDecrementAssignImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/ForFieldIncrementAssignConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/ForFieldIncrementAssignImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/ForFieldPostDecrementConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/ForFieldPostDecrementImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/ForFieldPostIncrementConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/ForFieldPostIncrementImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/ForFieldPreDecrementConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/ForFieldPreDecrementImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/ForFieldPreIncrementConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/ForFieldPreIncrementImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/ForStatementConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/ForStatementImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/FormControlConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/FormControlImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/FormDataFieldConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/FormDataFieldImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/FormDataSourceConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/FormDataSourceImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/FormElementTypeConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/FormElementTypeImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/FormModelElementConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/FormModelElementImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/FormNestedElementImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/FunctionCallConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/FunctionCallImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/FunctionDeclarationConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/FunctionDeclarationImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/GenericEvaluationImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/GenericXppTypeImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/GlobalOrderElementConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/GlobalOrderElementImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/GreaterThanExpressionConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/GreaterThanExpressionImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/GreaterThanOrEqualExpressionConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/GreaterThanOrEqualExpressionImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/GuidAttributeLiteralConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/GuidAttributeLiteralImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/GuidTypeConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/GuidTypeImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/IfStatementConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/IfStatementImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/IfThenElseStatementConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/IfThenElseStatementImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/ImplicitSelectionConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/ImplicitSelectionImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/InExpressionConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/InExpressionImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/InsertFieldSpecificationConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/InsertFieldSpecificationImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/InsertStatementConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/InsertStatementImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/InstanceNameImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/Int64AttributeLiteralConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/Int64AttributeLiteralImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/Int64LiteralExpressionConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/Int64LiteralExpressionImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/Int64TypeConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/Int64TypeImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/IntAttributeLiteralConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/IntAttributeLiteralImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/IntLiteralExpressionConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/IntLiteralExpressionImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/IntTypeConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/IntTypeImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/IntegerDivideExpressionConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/IntegerDivideExpressionImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/InterfaceConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/InterfaceImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/IntrinsicAttributeLiteralConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/IntrinsicAttributeLiteralImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/IntrinsicConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/IntrinsicImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/IsAsExpressionImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/IsClrExpressionConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/IsClrExpressionImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/IsExpressionConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/IsExpressionImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/JoinSpecificationConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/JoinSpecificationImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/LessThanExpressionConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/LessThanExpressionImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/LessThanOrEqualExpressionConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/LessThanOrEqualExpressionImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/LikeExpressionConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/LikeExpressionImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/LiteralExpressionImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/LocalDeclarationImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/LocalDeclarationsStatementConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/LocalDeclarationsStatementImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/LocatableImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/LocationConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/LocationImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/MaxAggregateSelectionConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/MaxAggregateSelectionImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/MethodConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/MethodImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/MethodOrDelegateImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/MinAggregateSelectionConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/MinAggregateSelectionImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/ModExpressionConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/ModExpressionImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/ModelElementImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/ModelElementUsingEntryConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/ModelElementUsingEntryImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/ModifierConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/ModifierImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/MoveCursorStatementConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/MoveCursorStatementImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/MultiplyExpressionConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/MultiplyExpressionImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/NamedFieldReferenceConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/NamedFieldReferenceImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/NamedTypeImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/NamedTypeInternalConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/NamedTypeInternalImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/NewCallConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/NewCallImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/NewClrArrayExpressionConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/NewClrArrayExpressionImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/NewClrCallConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/NewClrCallImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/NextExpressionConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/NextExpressionImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/NotEqualExpressionConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/NotEqualExpressionImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/NotExpressionConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/NotExpressionImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/NullLiteralExpressionConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/NullLiteralExpressionImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/NumberedFieldReferenceConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/NumberedFieldReferenceImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/OrExpressionConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/OrExpressionImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/OrderElementImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/ParameterDeclarationConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/ParameterDeclarationImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/PhysicalAndExpressionConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/PhysicalAndExpressionImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/PhysicalNotExpressionConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/PhysicalNotExpressionImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/PhysicalOrExpressionConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/PhysicalOrExpressionImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/PhysicalXorExpressionConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/PhysicalXorExpressionImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/PlaceholderConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/PlaceholderImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/PrintStatementConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/PrintStatementImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/ProvidedTypeConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/ProvidedTypeImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/ProvidedTypeStaticCallConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/ProvidedTypeStaticCallImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/QualifiedCallConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/QualifiedCallImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/QualifiedFieldConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/QualifiedFieldImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/QualifiedInstanceNameConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/QualifiedInstanceNameImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/QualifiedNumberedFieldConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/QualifiedNumberedFieldImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/QualifiedStaticCallConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/QualifiedStaticCallImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/QualifiedStaticFieldConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/QualifiedStaticFieldExpressionConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/QualifiedStaticFieldExpressionImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/QualifiedStaticFieldImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/QualifierImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/QueryConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/QueryDataSourceConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/QueryDataSourceHavingConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/QueryDataSourceHavingImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/QueryDataSourceImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/QueryDataSourceRangeConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/QueryDataSourceRangeImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/QueryDataSourceRelationConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/QueryDataSourceRelationImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/QueryImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/QueryModelElementConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/QueryModelElementImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/RealLiteralExpressionConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/RealLiteralExpressionImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/RelationalExpressionImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/RetryStatementConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/RetryStatementImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/ReturnStatementConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/ReturnStatementImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/SearchStatementConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/SearchStatementImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/SelectionFieldImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/SelectionImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/ShiftLeftExpressionConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/ShiftLeftExpressionImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/ShiftRightExpressionConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/ShiftRightExpressionImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/SimpleFieldConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/SimpleFieldImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/SimpleInstanceNameConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/SimpleInstanceNameImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/SimpleOrderElementConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/SimpleOrderElementImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/SimpleQualifierImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/SimpleQualifierInternalConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/SimpleQualifierInternalImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/StatementImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/StaticFieldConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/StaticFieldImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/StaticMethodCallConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/StaticMethodCallImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/StaticQualifierConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/StaticQualifierImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/StringAttributeLiteralConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/StringAttributeLiteralImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/StringLengthTypeConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/StringLengthTypeImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/StringLiteralExpressionConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/StringLiteralExpressionImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/StringTypeImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/StringTypeInternalConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/StringTypeInternalImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/SubtractExpressionConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/SubtractExpressionImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/SumAggregateSelectionConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/SumAggregateSelectionImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/SuperCallConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/SuperCallImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/SwitchCaseConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/SwitchCaseImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/SwitchStatementCaseEntryConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/SwitchStatementCaseEntryImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/SwitchStatementConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/SwitchStatementImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/TableConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/TableFieldDeclarationConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/TableFieldDeclarationImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/TableFieldReferenceImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/TableImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/TableLookupExpressionConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/TableLookupExpressionImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/ThrowStatementConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/ThrowStatementImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/TryStatementCatchEntryConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/TryStatementCatchEntryImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/TryStatementConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/TryStatementImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/TtsAbortStatementConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/TtsAbortStatementImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/TtsBeginStatementConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/TtsBeginStatementImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/TtsEndStatementConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/TtsEndStatementImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/TtsStatementImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/UnaryExpressionImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/UnaryMinusExpressionConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/UnaryMinusExpressionImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/UncheckedStatementConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/UncheckedStatementImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/UnspecifiedElementConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/UnspecifiedElementImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/UpdateStatementConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/UpdateStatementImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/UsingStatementConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/UsingStatementImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/ValidTimeStateDateConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/ValidTimeStateDateImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/ValidTimeStateImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/ValidTimeStateRangeConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/ValidTimeStateRangeImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/VarTypeConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/VarTypeImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/VariableDeclarationImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/VariableDeclarationInternalConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/VariableDeclarationInternalImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/VoidTypeConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/VoidTypeImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/WhileStatementConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/WhileStatementImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/XppTupleImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/XppTypeCompilationUnitConstructor.qll linguist-generated +/lib/codeql/xpp/elements/internal/XppTypeCompilationUnitImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/XppTypeImpl.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/AddExpression.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/AggregateSelection.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/AllFieldsSelection.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/AndExpression.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/AnyType.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/ArraySpecification.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/AsClrExpression.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/AsExpression.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/AssignDecrementStatement.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/AssignDivideStatement.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/AssignEqualStatement.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/AssignIncrementStatement.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/AssignMultipleFieldStatement.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/AssignMultiplyStatement.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/AssignPostDecrementStatement.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/AssignPostIncrementStatement.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/AssignPreDecrementStatement.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/AssignPreIncrementStatement.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/AssignmentBinary.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/AssignmentEventHandlerBase.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/AssignmentEventHandlerClr.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/AssignmentEventHandlerInstance.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/AssignmentEventHandlerStatic.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/AssignmentEventHandlerStaticInternal.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/AssignmentSingleField.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/AssignmentStatement.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/Ast.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/Attribute.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/AttributeExpression.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/AttributeList.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/AttributeLiteral.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/AttributeNamedParameterEntry.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/AvgAggregateSelection.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/BinaryExpression.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/BooleanAttributeLiteral.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/BooleanLiteralExpression.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/BooleanType.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/BreakStatement.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/BreakpointStatement.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/Case.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/CaseDefault.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/CaseValues.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/Catch.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/CatchAllValues.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/CatchExpression.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/CatchUpdateConflict.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/ChangeCompanyStatement.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/ChangeStatement.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/Class.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/ClassAccessModifier.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/ClassOrInterface.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/ClrEnumerationLiteralExpression.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/ClrType.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/Comment.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/CompilationUnit.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/CompilationUnitRegionEntry.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/CompoundStatement.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/ConditionalExpression.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/ContainerAttributeLiteral.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/ContainerLiteralExpression.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/ContainerType.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/ContinueStatement.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/CountAggregateSelection.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/CrossCompany.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/CrossCompanyAll.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/CrossCompanyContainer.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/DateAttributeLiteral.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/DateLiteralExpression.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/DateTimeAttributeLiteral.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/DateTimeLiteralExpression.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/DateTimeType.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/DateType.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/DblAttributeLiteral.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/DblType.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/Declaration.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/DefaultTypeAttributeLiteral.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/DefaultTypeLiteralExpression.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/Delegate.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/DeleteStatement.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/DivideExpression.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/DoWhileStatement.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/Element.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/EmptyExpression.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/EmptyStatement.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/EnumAttributeLiteral.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/EnumerationLiteralExpression.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/EnumerationType.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/EqualExpression.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/ErrorElement.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/Evaluation.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/EvaluationActualParameterEntry.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/ExplicitSelection.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/Expression.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/ExpressionCompilationUnit.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/ExpressionQualifier.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/ExpressionStatement.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/FieldAssignment.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/FieldDeclaration.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/FieldDeclarationInternal.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/FieldExpression.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/FieldExpressionInternal.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/FieldSelection.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/FieldSpecification.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/File.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/FindStatement.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/FlushStatement.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/ForAssign.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/ForDeclarationAssign.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/ForExpressionAssign.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/ForFieldAssign.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/ForFieldDecrementAssign.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/ForFieldIncrementAssign.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/ForFieldPostDecrement.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/ForFieldPostIncrement.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/ForFieldPreDecrement.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/ForFieldPreIncrement.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/ForStatement.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/FormControl.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/FormDataField.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/FormDataSource.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/FormElementType.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/FormModelElement.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/FormNestedElement.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/FunctionCall.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/FunctionDeclaration.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/GenericEvaluation.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/GenericXppType.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/GlobalOrderElement.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/GreaterThanExpression.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/GreaterThanOrEqualExpression.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/GuidAttributeLiteral.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/GuidType.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/IfStatement.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/IfThenElseStatement.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/ImplicitSelection.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/InExpression.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/InsertFieldSpecification.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/InsertStatement.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/InstanceName.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/Int64AttributeLiteral.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/Int64LiteralExpression.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/Int64Type.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/IntAttributeLiteral.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/IntLiteralExpression.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/IntType.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/IntegerDivideExpression.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/Interface.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/Intrinsic.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/IntrinsicAttributeLiteral.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/IsAsExpression.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/IsClrExpression.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/IsExpression.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/JoinSpecification.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/LessThanExpression.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/LessThanOrEqualExpression.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/LikeExpression.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/LiteralExpression.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/LocalDeclaration.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/LocalDeclarationsStatement.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/Locatable.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/Location.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/MaxAggregateSelection.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/Method.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/MethodOrDelegate.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/MinAggregateSelection.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/ModExpression.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/ModelElement.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/ModelElementUsingEntry.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/Modifier.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/MoveCursorStatement.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/MultiplyExpression.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/NamedFieldReference.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/NamedType.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/NamedTypeInternal.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/NewCall.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/NewClrArrayExpression.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/NewClrCall.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/NextExpression.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/NotEqualExpression.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/NotExpression.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/NullLiteralExpression.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/NumberedFieldReference.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/OrExpression.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/OrderElement.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/ParameterDeclaration.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/ParentChild.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/PhysicalAndExpression.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/PhysicalNotExpression.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/PhysicalOrExpression.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/PhysicalXorExpression.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/Placeholder.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/PrintStatement.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/ProvidedType.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/ProvidedTypeStaticCall.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/PureSynthConstructors.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/QualifiedCall.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/QualifiedField.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/QualifiedInstanceName.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/QualifiedNumberedField.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/QualifiedStaticCall.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/QualifiedStaticField.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/QualifiedStaticFieldExpression.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/Qualifier.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/Query.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/QueryDataSource.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/QueryDataSourceHaving.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/QueryDataSourceRange.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/QueryDataSourceRelation.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/QueryModelElement.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/Raw.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/RealLiteralExpression.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/RelationalExpression.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/RetryStatement.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/ReturnStatement.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/SearchStatement.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/Selection.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/SelectionField.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/ShiftLeftExpression.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/ShiftRightExpression.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/SimpleField.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/SimpleInstanceName.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/SimpleOrderElement.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/SimpleQualifier.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/SimpleQualifierInternal.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/Statement.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/StaticField.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/StaticMethodCall.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/StaticQualifier.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/StringAttributeLiteral.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/StringLengthType.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/StringLiteralExpression.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/StringType.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/StringTypeInternal.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/SubtractExpression.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/SumAggregateSelection.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/SuperCall.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/SwitchCase.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/SwitchStatement.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/SwitchStatementCaseEntry.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/Synth.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/SynthConstructors.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/Table.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/TableFieldDeclaration.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/TableFieldReference.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/TableLookupExpression.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/ThrowStatement.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/TryStatement.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/TryStatementCatchEntry.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/TtsAbortStatement.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/TtsBeginStatement.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/TtsEndStatement.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/TtsStatement.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/UnaryExpression.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/UnaryMinusExpression.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/UncheckedStatement.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/UnspecifiedElement.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/UpdateStatement.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/UsingStatement.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/ValidTimeState.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/ValidTimeStateDate.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/ValidTimeStateRange.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/VarType.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/VariableDeclaration.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/VariableDeclarationInternal.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/VoidType.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/WhileStatement.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/XppTuple.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/XppType.qll linguist-generated +/lib/codeql/xpp/elements/internal/generated/XppTypeCompilationUnit.qll linguist-generated +/lib/codeql/xpp/elements.qll linguist-generated diff --git a/xpp/ql/lib/codeql/xpp/elements.qll b/xpp/ql/lib/codeql/xpp/elements.qll new file mode 100644 index 000000000000..b759c5f5fa97 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements.qll @@ -0,0 +1,269 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module exports all modules providing `Element` subclasses. + */ + +import codeql.xpp.elements.AddExpression +import codeql.xpp.elements.AggregateSelection +import codeql.xpp.elements.AllFieldsSelection +import codeql.xpp.elements.AndExpression +import codeql.xpp.elements.AnyType +import codeql.xpp.elements.ArraySpecification +import codeql.xpp.elements.AsClrExpression +import codeql.xpp.elements.AsExpression +import codeql.xpp.elements.AssignDecrementStatement +import codeql.xpp.elements.AssignDivideStatement +import codeql.xpp.elements.AssignEqualStatement +import codeql.xpp.elements.AssignIncrementStatement +import codeql.xpp.elements.AssignMultipleFieldStatement +import codeql.xpp.elements.AssignMultiplyStatement +import codeql.xpp.elements.AssignPostDecrementStatement +import codeql.xpp.elements.AssignPostIncrementStatement +import codeql.xpp.elements.AssignPreDecrementStatement +import codeql.xpp.elements.AssignPreIncrementStatement +import codeql.xpp.elements.AssignmentBinary +import codeql.xpp.elements.AssignmentEventHandlerBase +import codeql.xpp.elements.AssignmentEventHandlerClr +import codeql.xpp.elements.AssignmentEventHandlerInstance +import codeql.xpp.elements.AssignmentEventHandlerStatic +import codeql.xpp.elements.AssignmentEventHandlerStaticInternal +import codeql.xpp.elements.AssignmentSingleField +import codeql.xpp.elements.AssignmentStatement +import codeql.xpp.elements.Ast +import codeql.xpp.elements.Attribute +import codeql.xpp.elements.AttributeExpression +import codeql.xpp.elements.AttributeList +import codeql.xpp.elements.AttributeLiteral +import codeql.xpp.elements.AttributeNamedParameterEntry +import codeql.xpp.elements.AvgAggregateSelection +import codeql.xpp.elements.BinaryExpression +import codeql.xpp.elements.BooleanAttributeLiteral +import codeql.xpp.elements.BooleanLiteralExpression +import codeql.xpp.elements.BooleanType +import codeql.xpp.elements.BreakStatement +import codeql.xpp.elements.BreakpointStatement +import codeql.xpp.elements.Case +import codeql.xpp.elements.CaseDefault +import codeql.xpp.elements.CaseValues +import codeql.xpp.elements.Catch +import codeql.xpp.elements.CatchAllValues +import codeql.xpp.elements.CatchExpression +import codeql.xpp.elements.CatchUpdateConflict +import codeql.xpp.elements.ChangeCompanyStatement +import codeql.xpp.elements.ChangeStatement +import codeql.xpp.elements.Class +import codeql.xpp.elements.ClassAccessModifier +import codeql.xpp.elements.ClassOrInterface +import codeql.xpp.elements.ClrEnumerationLiteralExpression +import codeql.xpp.elements.ClrType +import codeql.xpp.elements.Comment +import codeql.xpp.elements.CompilationUnit +import codeql.xpp.elements.CompilationUnitRegionEntry +import codeql.xpp.elements.CompoundStatement +import codeql.xpp.elements.ConditionalExpression +import codeql.xpp.elements.ContainerAttributeLiteral +import codeql.xpp.elements.ContainerLiteralExpression +import codeql.xpp.elements.ContainerType +import codeql.xpp.elements.ContinueStatement +import codeql.xpp.elements.CountAggregateSelection +import codeql.xpp.elements.CrossCompany +import codeql.xpp.elements.CrossCompanyAll +import codeql.xpp.elements.CrossCompanyContainer +import codeql.xpp.elements.DateAttributeLiteral +import codeql.xpp.elements.DateLiteralExpression +import codeql.xpp.elements.DateTimeAttributeLiteral +import codeql.xpp.elements.DateTimeLiteralExpression +import codeql.xpp.elements.DateTimeType +import codeql.xpp.elements.DateType +import codeql.xpp.elements.DblAttributeLiteral +import codeql.xpp.elements.DblType +import codeql.xpp.elements.Declaration +import codeql.xpp.elements.DefaultTypeAttributeLiteral +import codeql.xpp.elements.DefaultTypeLiteralExpression +import codeql.xpp.elements.Delegate +import codeql.xpp.elements.DeleteStatement +import codeql.xpp.elements.DivideExpression +import codeql.xpp.elements.DoWhileStatement +import codeql.xpp.elements.Element +import codeql.xpp.elements.EmptyExpression +import codeql.xpp.elements.EmptyStatement +import codeql.xpp.elements.EnumAttributeLiteral +import codeql.xpp.elements.EnumerationLiteralExpression +import codeql.xpp.elements.EnumerationType +import codeql.xpp.elements.EqualExpression +import codeql.xpp.elements.ErrorElement +import codeql.xpp.elements.Evaluation +import codeql.xpp.elements.EvaluationActualParameterEntry +import codeql.xpp.elements.ExplicitSelection +import codeql.xpp.elements.Expression +import codeql.xpp.elements.ExpressionCompilationUnit +import codeql.xpp.elements.ExpressionQualifier +import codeql.xpp.elements.ExpressionStatement +import codeql.xpp.elements.FieldAssignment +import codeql.xpp.elements.FieldDeclaration +import codeql.xpp.elements.FieldDeclarationInternal +import codeql.xpp.elements.FieldExpression +import codeql.xpp.elements.FieldExpressionInternal +import codeql.xpp.elements.FieldSelection +import codeql.xpp.elements.FieldSpecification +import codeql.xpp.elements.File +import codeql.xpp.elements.FindStatement +import codeql.xpp.elements.FlushStatement +import codeql.xpp.elements.ForAssign +import codeql.xpp.elements.ForDeclarationAssign +import codeql.xpp.elements.ForExpressionAssign +import codeql.xpp.elements.ForFieldAssign +import codeql.xpp.elements.ForFieldDecrementAssign +import codeql.xpp.elements.ForFieldIncrementAssign +import codeql.xpp.elements.ForFieldPostDecrement +import codeql.xpp.elements.ForFieldPostIncrement +import codeql.xpp.elements.ForFieldPreDecrement +import codeql.xpp.elements.ForFieldPreIncrement +import codeql.xpp.elements.ForStatement +import codeql.xpp.elements.FormControl +import codeql.xpp.elements.FormDataField +import codeql.xpp.elements.FormDataSource +import codeql.xpp.elements.FormElementType +import codeql.xpp.elements.FormModelElement +import codeql.xpp.elements.FormNestedElement +import codeql.xpp.elements.FunctionCall +import codeql.xpp.elements.FunctionDeclaration +import codeql.xpp.elements.GenericEvaluation +import codeql.xpp.elements.GenericXppType +import codeql.xpp.elements.GlobalOrderElement +import codeql.xpp.elements.GreaterThanExpression +import codeql.xpp.elements.GreaterThanOrEqualExpression +import codeql.xpp.elements.GuidAttributeLiteral +import codeql.xpp.elements.GuidType +import codeql.xpp.elements.IfStatement +import codeql.xpp.elements.IfThenElseStatement +import codeql.xpp.elements.ImplicitSelection +import codeql.xpp.elements.InExpression +import codeql.xpp.elements.InsertFieldSpecification +import codeql.xpp.elements.InsertStatement +import codeql.xpp.elements.InstanceName +import codeql.xpp.elements.Int64AttributeLiteral +import codeql.xpp.elements.Int64LiteralExpression +import codeql.xpp.elements.Int64Type +import codeql.xpp.elements.IntAttributeLiteral +import codeql.xpp.elements.IntLiteralExpression +import codeql.xpp.elements.IntType +import codeql.xpp.elements.IntegerDivideExpression +import codeql.xpp.elements.Interface +import codeql.xpp.elements.Intrinsic +import codeql.xpp.elements.IntrinsicAttributeLiteral +import codeql.xpp.elements.IsAsExpression +import codeql.xpp.elements.IsClrExpression +import codeql.xpp.elements.IsExpression +import codeql.xpp.elements.JoinSpecification +import codeql.xpp.elements.LessThanExpression +import codeql.xpp.elements.LessThanOrEqualExpression +import codeql.xpp.elements.LikeExpression +import codeql.xpp.elements.LiteralExpression +import codeql.xpp.elements.LocalDeclaration +import codeql.xpp.elements.LocalDeclarationsStatement +import codeql.xpp.elements.Locatable +import codeql.xpp.elements.Location +import codeql.xpp.elements.MaxAggregateSelection +import codeql.xpp.elements.Method +import codeql.xpp.elements.MethodOrDelegate +import codeql.xpp.elements.MinAggregateSelection +import codeql.xpp.elements.ModExpression +import codeql.xpp.elements.ModelElement +import codeql.xpp.elements.ModelElementUsingEntry +import codeql.xpp.elements.Modifier +import codeql.xpp.elements.MoveCursorStatement +import codeql.xpp.elements.MultiplyExpression +import codeql.xpp.elements.NamedFieldReference +import codeql.xpp.elements.NamedType +import codeql.xpp.elements.NamedTypeInternal +import codeql.xpp.elements.NewCall +import codeql.xpp.elements.NewClrArrayExpression +import codeql.xpp.elements.NewClrCall +import codeql.xpp.elements.NextExpression +import codeql.xpp.elements.NotEqualExpression +import codeql.xpp.elements.NotExpression +import codeql.xpp.elements.NullLiteralExpression +import codeql.xpp.elements.NumberedFieldReference +import codeql.xpp.elements.OrExpression +import codeql.xpp.elements.OrderElement +import codeql.xpp.elements.ParameterDeclaration +import codeql.xpp.elements.PhysicalAndExpression +import codeql.xpp.elements.PhysicalNotExpression +import codeql.xpp.elements.PhysicalOrExpression +import codeql.xpp.elements.PhysicalXorExpression +import codeql.xpp.elements.Placeholder +import codeql.xpp.elements.PrintStatement +import codeql.xpp.elements.ProvidedType +import codeql.xpp.elements.ProvidedTypeStaticCall +import codeql.xpp.elements.QualifiedCall +import codeql.xpp.elements.QualifiedField +import codeql.xpp.elements.QualifiedInstanceName +import codeql.xpp.elements.QualifiedNumberedField +import codeql.xpp.elements.QualifiedStaticCall +import codeql.xpp.elements.QualifiedStaticField +import codeql.xpp.elements.QualifiedStaticFieldExpression +import codeql.xpp.elements.Qualifier +import codeql.xpp.elements.Query +import codeql.xpp.elements.QueryDataSource +import codeql.xpp.elements.QueryDataSourceHaving +import codeql.xpp.elements.QueryDataSourceRange +import codeql.xpp.elements.QueryDataSourceRelation +import codeql.xpp.elements.QueryModelElement +import codeql.xpp.elements.RealLiteralExpression +import codeql.xpp.elements.RelationalExpression +import codeql.xpp.elements.RetryStatement +import codeql.xpp.elements.ReturnStatement +import codeql.xpp.elements.SearchStatement +import codeql.xpp.elements.Selection +import codeql.xpp.elements.SelectionField +import codeql.xpp.elements.ShiftLeftExpression +import codeql.xpp.elements.ShiftRightExpression +import codeql.xpp.elements.SimpleField +import codeql.xpp.elements.SimpleInstanceName +import codeql.xpp.elements.SimpleOrderElement +import codeql.xpp.elements.SimpleQualifier +import codeql.xpp.elements.SimpleQualifierInternal +import codeql.xpp.elements.Statement +import codeql.xpp.elements.StaticField +import codeql.xpp.elements.StaticMethodCall +import codeql.xpp.elements.StaticQualifier +import codeql.xpp.elements.StringAttributeLiteral +import codeql.xpp.elements.StringLengthType +import codeql.xpp.elements.StringLiteralExpression +import codeql.xpp.elements.StringType +import codeql.xpp.elements.StringTypeInternal +import codeql.xpp.elements.SubtractExpression +import codeql.xpp.elements.SumAggregateSelection +import codeql.xpp.elements.SuperCall +import codeql.xpp.elements.SwitchCase +import codeql.xpp.elements.SwitchStatement +import codeql.xpp.elements.SwitchStatementCaseEntry +import codeql.xpp.elements.Table +import codeql.xpp.elements.TableFieldDeclaration +import codeql.xpp.elements.TableFieldReference +import codeql.xpp.elements.TableLookupExpression +import codeql.xpp.elements.ThrowStatement +import codeql.xpp.elements.TryStatement +import codeql.xpp.elements.TryStatementCatchEntry +import codeql.xpp.elements.TtsAbortStatement +import codeql.xpp.elements.TtsBeginStatement +import codeql.xpp.elements.TtsEndStatement +import codeql.xpp.elements.TtsStatement +import codeql.xpp.elements.UnaryExpression +import codeql.xpp.elements.UnaryMinusExpression +import codeql.xpp.elements.UncheckedStatement +import codeql.xpp.elements.UnspecifiedElement +import codeql.xpp.elements.UpdateStatement +import codeql.xpp.elements.UsingStatement +import codeql.xpp.elements.ValidTimeState +import codeql.xpp.elements.ValidTimeStateDate +import codeql.xpp.elements.ValidTimeStateRange +import codeql.xpp.elements.VarType +import codeql.xpp.elements.VariableDeclaration +import codeql.xpp.elements.VariableDeclarationInternal +import codeql.xpp.elements.VoidType +import codeql.xpp.elements.WhileStatement +import codeql.xpp.elements.XppTuple +import codeql.xpp.elements.XppType +import codeql.xpp.elements.XppTypeCompilationUnit diff --git a/xpp/ql/lib/codeql/xpp/elements/AddExpression.qll b/xpp/ql/lib/codeql/xpp/elements/AddExpression.qll new file mode 100644 index 000000000000..bdae97c2436b --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/AddExpression.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `AddExpression`. + */ + +private import internal.AddExpressionImpl +import codeql.xpp.elements.BinaryExpression + +final class AddExpression = Impl::AddExpression; diff --git a/xpp/ql/lib/codeql/xpp/elements/AggregateSelection.qll b/xpp/ql/lib/codeql/xpp/elements/AggregateSelection.qll new file mode 100644 index 000000000000..bbea49d23f68 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/AggregateSelection.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `AggregateSelection`. + */ + +private import internal.AggregateSelectionImpl +import codeql.xpp.elements.SelectionField + +final class AggregateSelection = Impl::AggregateSelection; diff --git a/xpp/ql/lib/codeql/xpp/elements/AllFieldsSelection.qll b/xpp/ql/lib/codeql/xpp/elements/AllFieldsSelection.qll new file mode 100644 index 000000000000..41fe685a371e --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/AllFieldsSelection.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `AllFieldsSelection`. + */ + +private import internal.AllFieldsSelectionImpl +import codeql.xpp.elements.Selection + +final class AllFieldsSelection = Impl::AllFieldsSelection; diff --git a/xpp/ql/lib/codeql/xpp/elements/AndExpression.qll b/xpp/ql/lib/codeql/xpp/elements/AndExpression.qll new file mode 100644 index 000000000000..eaa0ef9fd558 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/AndExpression.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `AndExpression`. + */ + +private import internal.AndExpressionImpl +import codeql.xpp.elements.BinaryExpression + +final class AndExpression = Impl::AndExpression; diff --git a/xpp/ql/lib/codeql/xpp/elements/AnyType.qll b/xpp/ql/lib/codeql/xpp/elements/AnyType.qll new file mode 100644 index 000000000000..3cabbc4184a2 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/AnyType.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `AnyType`. + */ + +private import internal.AnyTypeImpl +import codeql.xpp.elements.XppType + +final class AnyType = Impl::AnyType; diff --git a/xpp/ql/lib/codeql/xpp/elements/ArraySpecification.qll b/xpp/ql/lib/codeql/xpp/elements/ArraySpecification.qll new file mode 100644 index 000000000000..8a4aa9fa737e --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/ArraySpecification.qll @@ -0,0 +1,10 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `ArraySpecification`. + */ + +private import internal.ArraySpecificationImpl +import codeql.xpp.elements.Ast +import codeql.xpp.elements.Expression + +final class ArraySpecification = Impl::ArraySpecification; diff --git a/xpp/ql/lib/codeql/xpp/elements/AsClrExpression.qll b/xpp/ql/lib/codeql/xpp/elements/AsClrExpression.qll new file mode 100644 index 000000000000..56b99950db14 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/AsClrExpression.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `AsClrExpression`. + */ + +private import internal.AsClrExpressionImpl +import codeql.xpp.elements.IsAsExpression + +final class AsClrExpression = Impl::AsClrExpression; diff --git a/xpp/ql/lib/codeql/xpp/elements/AsExpression.qll b/xpp/ql/lib/codeql/xpp/elements/AsExpression.qll new file mode 100644 index 000000000000..565a21aa6c0f --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/AsExpression.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `AsExpression`. + */ + +private import internal.AsExpressionImpl +import codeql.xpp.elements.IsAsExpression + +final class AsExpression = Impl::AsExpression; diff --git a/xpp/ql/lib/codeql/xpp/elements/AssignDecrementStatement.qll b/xpp/ql/lib/codeql/xpp/elements/AssignDecrementStatement.qll new file mode 100644 index 000000000000..39ae97560877 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/AssignDecrementStatement.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `AssignDecrementStatement`. + */ + +private import internal.AssignDecrementStatementImpl +import codeql.xpp.elements.AssignmentBinary + +final class AssignDecrementStatement = Impl::AssignDecrementStatement; diff --git a/xpp/ql/lib/codeql/xpp/elements/AssignDivideStatement.qll b/xpp/ql/lib/codeql/xpp/elements/AssignDivideStatement.qll new file mode 100644 index 000000000000..7e45f96bf67f --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/AssignDivideStatement.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `AssignDivideStatement`. + */ + +private import internal.AssignDivideStatementImpl +import codeql.xpp.elements.AssignmentBinary + +final class AssignDivideStatement = Impl::AssignDivideStatement; diff --git a/xpp/ql/lib/codeql/xpp/elements/AssignEqualStatement.qll b/xpp/ql/lib/codeql/xpp/elements/AssignEqualStatement.qll new file mode 100644 index 000000000000..a403292e05e7 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/AssignEqualStatement.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `AssignEqualStatement`. + */ + +private import internal.AssignEqualStatementImpl +import codeql.xpp.elements.AssignmentBinary + +final class AssignEqualStatement = Impl::AssignEqualStatement; diff --git a/xpp/ql/lib/codeql/xpp/elements/AssignIncrementStatement.qll b/xpp/ql/lib/codeql/xpp/elements/AssignIncrementStatement.qll new file mode 100644 index 000000000000..57bec1d597a1 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/AssignIncrementStatement.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `AssignIncrementStatement`. + */ + +private import internal.AssignIncrementStatementImpl +import codeql.xpp.elements.AssignmentBinary + +final class AssignIncrementStatement = Impl::AssignIncrementStatement; diff --git a/xpp/ql/lib/codeql/xpp/elements/AssignMultipleFieldStatement.qll b/xpp/ql/lib/codeql/xpp/elements/AssignMultipleFieldStatement.qll new file mode 100644 index 000000000000..bd6b8dcbfb6c --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/AssignMultipleFieldStatement.qll @@ -0,0 +1,11 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `AssignMultipleFieldStatement`. + */ + +private import internal.AssignMultipleFieldStatementImpl +import codeql.xpp.elements.AssignmentStatement +import codeql.xpp.elements.Expression +import codeql.xpp.elements.FieldSpecification + +final class AssignMultipleFieldStatement = Impl::AssignMultipleFieldStatement; diff --git a/xpp/ql/lib/codeql/xpp/elements/AssignMultiplyStatement.qll b/xpp/ql/lib/codeql/xpp/elements/AssignMultiplyStatement.qll new file mode 100644 index 000000000000..fbce71ae014c --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/AssignMultiplyStatement.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `AssignMultiplyStatement`. + */ + +private import internal.AssignMultiplyStatementImpl +import codeql.xpp.elements.AssignmentBinary + +final class AssignMultiplyStatement = Impl::AssignMultiplyStatement; diff --git a/xpp/ql/lib/codeql/xpp/elements/AssignPostDecrementStatement.qll b/xpp/ql/lib/codeql/xpp/elements/AssignPostDecrementStatement.qll new file mode 100644 index 000000000000..35d12ae700ce --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/AssignPostDecrementStatement.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `AssignPostDecrementStatement`. + */ + +private import internal.AssignPostDecrementStatementImpl +import codeql.xpp.elements.AssignmentSingleField + +final class AssignPostDecrementStatement = Impl::AssignPostDecrementStatement; diff --git a/xpp/ql/lib/codeql/xpp/elements/AssignPostIncrementStatement.qll b/xpp/ql/lib/codeql/xpp/elements/AssignPostIncrementStatement.qll new file mode 100644 index 000000000000..7ce691725d1f --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/AssignPostIncrementStatement.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `AssignPostIncrementStatement`. + */ + +private import internal.AssignPostIncrementStatementImpl +import codeql.xpp.elements.AssignmentSingleField + +final class AssignPostIncrementStatement = Impl::AssignPostIncrementStatement; diff --git a/xpp/ql/lib/codeql/xpp/elements/AssignPreDecrementStatement.qll b/xpp/ql/lib/codeql/xpp/elements/AssignPreDecrementStatement.qll new file mode 100644 index 000000000000..9fbde773b552 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/AssignPreDecrementStatement.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `AssignPreDecrementStatement`. + */ + +private import internal.AssignPreDecrementStatementImpl +import codeql.xpp.elements.AssignmentSingleField + +final class AssignPreDecrementStatement = Impl::AssignPreDecrementStatement; diff --git a/xpp/ql/lib/codeql/xpp/elements/AssignPreIncrementStatement.qll b/xpp/ql/lib/codeql/xpp/elements/AssignPreIncrementStatement.qll new file mode 100644 index 000000000000..034aff541ab5 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/AssignPreIncrementStatement.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `AssignPreIncrementStatement`. + */ + +private import internal.AssignPreIncrementStatementImpl +import codeql.xpp.elements.AssignmentSingleField + +final class AssignPreIncrementStatement = Impl::AssignPreIncrementStatement; diff --git a/xpp/ql/lib/codeql/xpp/elements/AssignmentBinary.qll b/xpp/ql/lib/codeql/xpp/elements/AssignmentBinary.qll new file mode 100644 index 000000000000..65a7aea27693 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/AssignmentBinary.qll @@ -0,0 +1,10 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `AssignmentBinary`. + */ + +private import internal.AssignmentBinaryImpl +import codeql.xpp.elements.AssignmentSingleField +import codeql.xpp.elements.Expression + +final class AssignmentBinary = Impl::AssignmentBinary; diff --git a/xpp/ql/lib/codeql/xpp/elements/AssignmentEventHandlerBase.qll b/xpp/ql/lib/codeql/xpp/elements/AssignmentEventHandlerBase.qll new file mode 100644 index 000000000000..9ca6f87c5135 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/AssignmentEventHandlerBase.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `AssignmentEventHandlerBase`. + */ + +private import internal.AssignmentEventHandlerBaseImpl +import codeql.xpp.elements.AssignmentSingleField + +final class AssignmentEventHandlerBase = Impl::AssignmentEventHandlerBase; diff --git a/xpp/ql/lib/codeql/xpp/elements/AssignmentEventHandlerClr.qll b/xpp/ql/lib/codeql/xpp/elements/AssignmentEventHandlerClr.qll new file mode 100644 index 000000000000..d85c0655ee70 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/AssignmentEventHandlerClr.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `AssignmentEventHandlerClr`. + */ + +private import internal.AssignmentEventHandlerClrImpl +import codeql.xpp.elements.AssignmentEventHandlerStatic + +final class AssignmentEventHandlerClr = Impl::AssignmentEventHandlerClr; diff --git a/xpp/ql/lib/codeql/xpp/elements/AssignmentEventHandlerInstance.qll b/xpp/ql/lib/codeql/xpp/elements/AssignmentEventHandlerInstance.qll new file mode 100644 index 000000000000..1a69c0875d68 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/AssignmentEventHandlerInstance.qll @@ -0,0 +1,10 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `AssignmentEventHandlerInstance`. + */ + +private import internal.AssignmentEventHandlerInstanceImpl +import codeql.xpp.elements.AssignmentEventHandlerBase +import codeql.xpp.elements.Qualifier + +final class AssignmentEventHandlerInstance = Impl::AssignmentEventHandlerInstance; diff --git a/xpp/ql/lib/codeql/xpp/elements/AssignmentEventHandlerStatic.qll b/xpp/ql/lib/codeql/xpp/elements/AssignmentEventHandlerStatic.qll new file mode 100644 index 000000000000..1aa2d1a71cdf --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/AssignmentEventHandlerStatic.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `AssignmentEventHandlerStatic`. + */ + +private import internal.AssignmentEventHandlerStaticImpl +import codeql.xpp.elements.AssignmentEventHandlerBase + +final class AssignmentEventHandlerStatic = Impl::AssignmentEventHandlerStatic; diff --git a/xpp/ql/lib/codeql/xpp/elements/AssignmentEventHandlerStaticInternal.qll b/xpp/ql/lib/codeql/xpp/elements/AssignmentEventHandlerStaticInternal.qll new file mode 100644 index 000000000000..e3a242e487b8 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/AssignmentEventHandlerStaticInternal.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `AssignmentEventHandlerStaticInternal`. + */ + +private import internal.AssignmentEventHandlerStaticInternalImpl +import codeql.xpp.elements.AssignmentEventHandlerStatic + +final class AssignmentEventHandlerStaticInternal = Impl::AssignmentEventHandlerStaticInternal; diff --git a/xpp/ql/lib/codeql/xpp/elements/AssignmentSingleField.qll b/xpp/ql/lib/codeql/xpp/elements/AssignmentSingleField.qll new file mode 100644 index 000000000000..98ae0a380cdf --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/AssignmentSingleField.qll @@ -0,0 +1,10 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `AssignmentSingleField`. + */ + +private import internal.AssignmentSingleFieldImpl +import codeql.xpp.elements.AssignmentStatement +import codeql.xpp.elements.FieldSpecification + +final class AssignmentSingleField = Impl::AssignmentSingleField; diff --git a/xpp/ql/lib/codeql/xpp/elements/AssignmentStatement.qll b/xpp/ql/lib/codeql/xpp/elements/AssignmentStatement.qll new file mode 100644 index 000000000000..5f3978d6d6ce --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/AssignmentStatement.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `AssignmentStatement`. + */ + +private import internal.AssignmentStatementImpl +import codeql.xpp.elements.Statement + +final class AssignmentStatement = Impl::AssignmentStatement; diff --git a/xpp/ql/lib/codeql/xpp/elements/Ast.qll b/xpp/ql/lib/codeql/xpp/elements/Ast.qll new file mode 100644 index 000000000000..fe2d96c18425 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/Ast.qll @@ -0,0 +1,15 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `Ast`. + */ + +private import internal.AstImpl +import codeql.xpp.elements.Locatable + +/** + * Root of the X++ abstract syntax tree. + * + * This mirrors `Microsoft.Dynamics.AX.Metadata.XppCompiler.Ast`, the base class of the + * X++ compiler's own AST. + */ +final class Ast = Impl::Ast; diff --git a/xpp/ql/lib/codeql/xpp/elements/Attribute.qll b/xpp/ql/lib/codeql/xpp/elements/Attribute.qll new file mode 100644 index 000000000000..9d393b4828db --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/Attribute.qll @@ -0,0 +1,11 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `Attribute`. + */ + +private import internal.AttributeImpl +import codeql.xpp.elements.Ast +import codeql.xpp.elements.AttributeExpression +import codeql.xpp.elements.AttributeNamedParameterEntry + +final class Attribute = Impl::Attribute; diff --git a/xpp/ql/lib/codeql/xpp/elements/AttributeExpression.qll b/xpp/ql/lib/codeql/xpp/elements/AttributeExpression.qll new file mode 100644 index 000000000000..6f694e289611 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/AttributeExpression.qll @@ -0,0 +1,10 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `AttributeExpression`. + */ + +private import internal.AttributeExpressionImpl +import codeql.xpp.elements.Ast +import codeql.xpp.elements.AttributeLiteral + +final class AttributeExpression = Impl::AttributeExpression; diff --git a/xpp/ql/lib/codeql/xpp/elements/AttributeList.qll b/xpp/ql/lib/codeql/xpp/elements/AttributeList.qll new file mode 100644 index 000000000000..97c5cce39a0a --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/AttributeList.qll @@ -0,0 +1,10 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `AttributeList`. + */ + +private import internal.AttributeListImpl +import codeql.xpp.elements.Ast +import codeql.xpp.elements.Attribute + +final class AttributeList = Impl::AttributeList; diff --git a/xpp/ql/lib/codeql/xpp/elements/AttributeLiteral.qll b/xpp/ql/lib/codeql/xpp/elements/AttributeLiteral.qll new file mode 100644 index 000000000000..ed394762176a --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/AttributeLiteral.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `AttributeLiteral`. + */ + +private import internal.AttributeLiteralImpl +import codeql.xpp.elements.Ast + +final class AttributeLiteral = Impl::AttributeLiteral; diff --git a/xpp/ql/lib/codeql/xpp/elements/AttributeNamedParameterEntry.qll b/xpp/ql/lib/codeql/xpp/elements/AttributeNamedParameterEntry.qll new file mode 100644 index 000000000000..392554c853b2 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/AttributeNamedParameterEntry.qll @@ -0,0 +1,10 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `AttributeNamedParameterEntry`. + */ + +private import internal.AttributeNamedParameterEntryImpl +import codeql.xpp.elements.AttributeExpression +import codeql.xpp.elements.XppTuple + +final class AttributeNamedParameterEntry = Impl::AttributeNamedParameterEntry; diff --git a/xpp/ql/lib/codeql/xpp/elements/AvgAggregateSelection.qll b/xpp/ql/lib/codeql/xpp/elements/AvgAggregateSelection.qll new file mode 100644 index 000000000000..a2f09afa8bf9 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/AvgAggregateSelection.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `AvgAggregateSelection`. + */ + +private import internal.AvgAggregateSelectionImpl +import codeql.xpp.elements.AggregateSelection + +final class AvgAggregateSelection = Impl::AvgAggregateSelection; diff --git a/xpp/ql/lib/codeql/xpp/elements/BinaryExpression.qll b/xpp/ql/lib/codeql/xpp/elements/BinaryExpression.qll new file mode 100644 index 000000000000..f9983c51513b --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/BinaryExpression.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `BinaryExpression`. + */ + +private import internal.BinaryExpressionImpl +import codeql.xpp.elements.Expression + +final class BinaryExpression = Impl::BinaryExpression; diff --git a/xpp/ql/lib/codeql/xpp/elements/BooleanAttributeLiteral.qll b/xpp/ql/lib/codeql/xpp/elements/BooleanAttributeLiteral.qll new file mode 100644 index 000000000000..ba31949c976a --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/BooleanAttributeLiteral.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `BooleanAttributeLiteral`. + */ + +private import internal.BooleanAttributeLiteralImpl +import codeql.xpp.elements.DefaultTypeAttributeLiteral + +final class BooleanAttributeLiteral = Impl::BooleanAttributeLiteral; diff --git a/xpp/ql/lib/codeql/xpp/elements/BooleanLiteralExpression.qll b/xpp/ql/lib/codeql/xpp/elements/BooleanLiteralExpression.qll new file mode 100644 index 000000000000..1903aed53aaf --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/BooleanLiteralExpression.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `BooleanLiteralExpression`. + */ + +private import internal.BooleanLiteralExpressionImpl +import codeql.xpp.elements.DefaultTypeLiteralExpression + +final class BooleanLiteralExpression = Impl::BooleanLiteralExpression; diff --git a/xpp/ql/lib/codeql/xpp/elements/BooleanType.qll b/xpp/ql/lib/codeql/xpp/elements/BooleanType.qll new file mode 100644 index 000000000000..dc5b2eda5be8 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/BooleanType.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `BooleanType`. + */ + +private import internal.BooleanTypeImpl +import codeql.xpp.elements.XppType + +final class BooleanType = Impl::BooleanType; diff --git a/xpp/ql/lib/codeql/xpp/elements/BreakStatement.qll b/xpp/ql/lib/codeql/xpp/elements/BreakStatement.qll new file mode 100644 index 000000000000..8cd4899223ed --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/BreakStatement.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `BreakStatement`. + */ + +private import internal.BreakStatementImpl +import codeql.xpp.elements.Statement + +final class BreakStatement = Impl::BreakStatement; diff --git a/xpp/ql/lib/codeql/xpp/elements/BreakpointStatement.qll b/xpp/ql/lib/codeql/xpp/elements/BreakpointStatement.qll new file mode 100644 index 000000000000..de19eaa8a41f --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/BreakpointStatement.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `BreakpointStatement`. + */ + +private import internal.BreakpointStatementImpl +import codeql.xpp.elements.Statement + +final class BreakpointStatement = Impl::BreakpointStatement; diff --git a/xpp/ql/lib/codeql/xpp/elements/Case.qll b/xpp/ql/lib/codeql/xpp/elements/Case.qll new file mode 100644 index 000000000000..e4593d927777 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/Case.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `Case`. + */ + +private import internal.CaseImpl +import codeql.xpp.elements.Ast + +final class Case = Impl::Case; diff --git a/xpp/ql/lib/codeql/xpp/elements/CaseDefault.qll b/xpp/ql/lib/codeql/xpp/elements/CaseDefault.qll new file mode 100644 index 000000000000..de707113c510 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/CaseDefault.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `CaseDefault`. + */ + +private import internal.CaseDefaultImpl +import codeql.xpp.elements.Case + +final class CaseDefault = Impl::CaseDefault; diff --git a/xpp/ql/lib/codeql/xpp/elements/CaseValues.qll b/xpp/ql/lib/codeql/xpp/elements/CaseValues.qll new file mode 100644 index 000000000000..86a094d109d5 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/CaseValues.qll @@ -0,0 +1,10 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `CaseValues`. + */ + +private import internal.CaseValuesImpl +import codeql.xpp.elements.Case +import codeql.xpp.elements.Expression + +final class CaseValues = Impl::CaseValues; diff --git a/xpp/ql/lib/codeql/xpp/elements/Catch.qll b/xpp/ql/lib/codeql/xpp/elements/Catch.qll new file mode 100644 index 000000000000..aec17540251a --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/Catch.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `Catch`. + */ + +private import internal.CatchImpl +import codeql.xpp.elements.Ast + +final class Catch = Impl::Catch; diff --git a/xpp/ql/lib/codeql/xpp/elements/CatchAllValues.qll b/xpp/ql/lib/codeql/xpp/elements/CatchAllValues.qll new file mode 100644 index 000000000000..cd618d58df28 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/CatchAllValues.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `CatchAllValues`. + */ + +private import internal.CatchAllValuesImpl +import codeql.xpp.elements.Catch + +final class CatchAllValues = Impl::CatchAllValues; diff --git a/xpp/ql/lib/codeql/xpp/elements/CatchExpression.qll b/xpp/ql/lib/codeql/xpp/elements/CatchExpression.qll new file mode 100644 index 000000000000..7cf544e7b699 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/CatchExpression.qll @@ -0,0 +1,10 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `CatchExpression`. + */ + +private import internal.CatchExpressionImpl +import codeql.xpp.elements.Catch +import codeql.xpp.elements.Expression + +final class CatchExpression = Impl::CatchExpression; diff --git a/xpp/ql/lib/codeql/xpp/elements/CatchUpdateConflict.qll b/xpp/ql/lib/codeql/xpp/elements/CatchUpdateConflict.qll new file mode 100644 index 000000000000..892d6f36305f --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/CatchUpdateConflict.qll @@ -0,0 +1,11 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `CatchUpdateConflict`. + */ + +private import internal.CatchUpdateConflictImpl +import codeql.xpp.elements.Catch +import codeql.xpp.elements.Expression +import codeql.xpp.elements.InstanceName + +final class CatchUpdateConflict = Impl::CatchUpdateConflict; diff --git a/xpp/ql/lib/codeql/xpp/elements/ChangeCompanyStatement.qll b/xpp/ql/lib/codeql/xpp/elements/ChangeCompanyStatement.qll new file mode 100644 index 000000000000..217384f894b0 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/ChangeCompanyStatement.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `ChangeCompanyStatement`. + */ + +private import internal.ChangeCompanyStatementImpl +import codeql.xpp.elements.ChangeStatement + +final class ChangeCompanyStatement = Impl::ChangeCompanyStatement; diff --git a/xpp/ql/lib/codeql/xpp/elements/ChangeStatement.qll b/xpp/ql/lib/codeql/xpp/elements/ChangeStatement.qll new file mode 100644 index 000000000000..dcbfb2fc9935 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/ChangeStatement.qll @@ -0,0 +1,10 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `ChangeStatement`. + */ + +private import internal.ChangeStatementImpl +import codeql.xpp.elements.Expression +import codeql.xpp.elements.Statement + +final class ChangeStatement = Impl::ChangeStatement; diff --git a/xpp/ql/lib/codeql/xpp/elements/Class.qll b/xpp/ql/lib/codeql/xpp/elements/Class.qll new file mode 100644 index 000000000000..2f94c944960c --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/Class.qll @@ -0,0 +1,10 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `Class`. + */ + +private import internal.ClassImpl +import codeql.xpp.elements.ClassOrInterface +import codeql.xpp.elements.FieldDeclaration + +final class Class = Impl::Class; diff --git a/xpp/ql/lib/codeql/xpp/elements/ClassAccessModifier.qll b/xpp/ql/lib/codeql/xpp/elements/ClassAccessModifier.qll new file mode 100644 index 000000000000..f4eb3773aba4 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/ClassAccessModifier.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `ClassAccessModifier`. + */ + +private import internal.ClassAccessModifierImpl +import codeql.xpp.elements.Ast + +final class ClassAccessModifier = Impl::ClassAccessModifier; diff --git a/xpp/ql/lib/codeql/xpp/elements/ClassOrInterface.qll b/xpp/ql/lib/codeql/xpp/elements/ClassOrInterface.qll new file mode 100644 index 000000000000..7ab5e09be7ba --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/ClassOrInterface.qll @@ -0,0 +1,10 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `ClassOrInterface`. + */ + +private import internal.ClassOrInterfaceImpl +import codeql.xpp.elements.AttributeList +import codeql.xpp.elements.ModelElement + +final class ClassOrInterface = Impl::ClassOrInterface; diff --git a/xpp/ql/lib/codeql/xpp/elements/ClrEnumerationLiteralExpression.qll b/xpp/ql/lib/codeql/xpp/elements/ClrEnumerationLiteralExpression.qll new file mode 100644 index 000000000000..48cb727ea7de --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/ClrEnumerationLiteralExpression.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `ClrEnumerationLiteralExpression`. + */ + +private import internal.ClrEnumerationLiteralExpressionImpl +import codeql.xpp.elements.LiteralExpression + +final class ClrEnumerationLiteralExpression = Impl::ClrEnumerationLiteralExpression; diff --git a/xpp/ql/lib/codeql/xpp/elements/ClrType.qll b/xpp/ql/lib/codeql/xpp/elements/ClrType.qll new file mode 100644 index 000000000000..912ca1bd547a --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/ClrType.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `ClrType`. + */ + +private import internal.ClrTypeImpl +import codeql.xpp.elements.GenericXppType + +final class ClrType = Impl::ClrType; diff --git a/xpp/ql/lib/codeql/xpp/elements/Comment.qll b/xpp/ql/lib/codeql/xpp/elements/Comment.qll new file mode 100644 index 000000000000..5351f5c808a7 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/Comment.qll @@ -0,0 +1,12 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `Comment`. + */ + +private import internal.CommentImpl +import codeql.xpp.elements.Locatable + +/** + * A comment in X++ source. + */ +final class Comment = Impl::Comment; diff --git a/xpp/ql/lib/codeql/xpp/elements/CompilationUnit.qll b/xpp/ql/lib/codeql/xpp/elements/CompilationUnit.qll new file mode 100644 index 000000000000..9e050ab18ad8 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/CompilationUnit.qll @@ -0,0 +1,11 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `CompilationUnit`. + */ + +private import internal.CompilationUnitImpl +import codeql.xpp.elements.Ast +import codeql.xpp.elements.Comment +import codeql.xpp.elements.CompilationUnitRegionEntry + +final class CompilationUnit = Impl::CompilationUnit; diff --git a/xpp/ql/lib/codeql/xpp/elements/CompilationUnitRegionEntry.qll b/xpp/ql/lib/codeql/xpp/elements/CompilationUnitRegionEntry.qll new file mode 100644 index 000000000000..cf6d9d3ee2ea --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/CompilationUnitRegionEntry.qll @@ -0,0 +1,10 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `CompilationUnitRegionEntry`. + */ + +private import internal.CompilationUnitRegionEntryImpl +import codeql.xpp.elements.Comment +import codeql.xpp.elements.XppTuple + +final class CompilationUnitRegionEntry = Impl::CompilationUnitRegionEntry; diff --git a/xpp/ql/lib/codeql/xpp/elements/CompoundStatement.qll b/xpp/ql/lib/codeql/xpp/elements/CompoundStatement.qll new file mode 100644 index 000000000000..66a2cc5518cd --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/CompoundStatement.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `CompoundStatement`. + */ + +private import internal.CompoundStatementImpl +import codeql.xpp.elements.Statement + +final class CompoundStatement = Impl::CompoundStatement; diff --git a/xpp/ql/lib/codeql/xpp/elements/ConditionalExpression.qll b/xpp/ql/lib/codeql/xpp/elements/ConditionalExpression.qll new file mode 100644 index 000000000000..31951dd540d9 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/ConditionalExpression.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `ConditionalExpression`. + */ + +private import internal.ConditionalExpressionImpl +import codeql.xpp.elements.Expression + +final class ConditionalExpression = Impl::ConditionalExpression; diff --git a/xpp/ql/lib/codeql/xpp/elements/ContainerAttributeLiteral.qll b/xpp/ql/lib/codeql/xpp/elements/ContainerAttributeLiteral.qll new file mode 100644 index 000000000000..1b7c4ae5d656 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/ContainerAttributeLiteral.qll @@ -0,0 +1,10 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `ContainerAttributeLiteral`. + */ + +private import internal.ContainerAttributeLiteralImpl +import codeql.xpp.elements.AttributeExpression +import codeql.xpp.elements.AttributeLiteral + +final class ContainerAttributeLiteral = Impl::ContainerAttributeLiteral; diff --git a/xpp/ql/lib/codeql/xpp/elements/ContainerLiteralExpression.qll b/xpp/ql/lib/codeql/xpp/elements/ContainerLiteralExpression.qll new file mode 100644 index 000000000000..4887996ea189 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/ContainerLiteralExpression.qll @@ -0,0 +1,10 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `ContainerLiteralExpression`. + */ + +private import internal.ContainerLiteralExpressionImpl +import codeql.xpp.elements.Expression +import codeql.xpp.elements.LiteralExpression + +final class ContainerLiteralExpression = Impl::ContainerLiteralExpression; diff --git a/xpp/ql/lib/codeql/xpp/elements/ContainerType.qll b/xpp/ql/lib/codeql/xpp/elements/ContainerType.qll new file mode 100644 index 000000000000..238ab543c3cd --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/ContainerType.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `ContainerType`. + */ + +private import internal.ContainerTypeImpl +import codeql.xpp.elements.XppType + +final class ContainerType = Impl::ContainerType; diff --git a/xpp/ql/lib/codeql/xpp/elements/ContinueStatement.qll b/xpp/ql/lib/codeql/xpp/elements/ContinueStatement.qll new file mode 100644 index 000000000000..d47345e658f6 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/ContinueStatement.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `ContinueStatement`. + */ + +private import internal.ContinueStatementImpl +import codeql.xpp.elements.Statement + +final class ContinueStatement = Impl::ContinueStatement; diff --git a/xpp/ql/lib/codeql/xpp/elements/CountAggregateSelection.qll b/xpp/ql/lib/codeql/xpp/elements/CountAggregateSelection.qll new file mode 100644 index 000000000000..9248a1699216 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/CountAggregateSelection.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `CountAggregateSelection`. + */ + +private import internal.CountAggregateSelectionImpl +import codeql.xpp.elements.AggregateSelection + +final class CountAggregateSelection = Impl::CountAggregateSelection; diff --git a/xpp/ql/lib/codeql/xpp/elements/CrossCompany.qll b/xpp/ql/lib/codeql/xpp/elements/CrossCompany.qll new file mode 100644 index 000000000000..5c435fe91f0d --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/CrossCompany.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `CrossCompany`. + */ + +private import internal.CrossCompanyImpl +import codeql.xpp.elements.Ast + +final class CrossCompany = Impl::CrossCompany; diff --git a/xpp/ql/lib/codeql/xpp/elements/CrossCompanyAll.qll b/xpp/ql/lib/codeql/xpp/elements/CrossCompanyAll.qll new file mode 100644 index 000000000000..2a76797fb302 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/CrossCompanyAll.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `CrossCompanyAll`. + */ + +private import internal.CrossCompanyAllImpl +import codeql.xpp.elements.CrossCompany + +final class CrossCompanyAll = Impl::CrossCompanyAll; diff --git a/xpp/ql/lib/codeql/xpp/elements/CrossCompanyContainer.qll b/xpp/ql/lib/codeql/xpp/elements/CrossCompanyContainer.qll new file mode 100644 index 000000000000..876aac430909 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/CrossCompanyContainer.qll @@ -0,0 +1,10 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `CrossCompanyContainer`. + */ + +private import internal.CrossCompanyContainerImpl +import codeql.xpp.elements.CrossCompany +import codeql.xpp.elements.Expression + +final class CrossCompanyContainer = Impl::CrossCompanyContainer; diff --git a/xpp/ql/lib/codeql/xpp/elements/DateAttributeLiteral.qll b/xpp/ql/lib/codeql/xpp/elements/DateAttributeLiteral.qll new file mode 100644 index 000000000000..c635259c4b1f --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/DateAttributeLiteral.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `DateAttributeLiteral`. + */ + +private import internal.DateAttributeLiteralImpl +import codeql.xpp.elements.DefaultTypeAttributeLiteral + +final class DateAttributeLiteral = Impl::DateAttributeLiteral; diff --git a/xpp/ql/lib/codeql/xpp/elements/DateLiteralExpression.qll b/xpp/ql/lib/codeql/xpp/elements/DateLiteralExpression.qll new file mode 100644 index 000000000000..4c739c93382b --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/DateLiteralExpression.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `DateLiteralExpression`. + */ + +private import internal.DateLiteralExpressionImpl +import codeql.xpp.elements.DefaultTypeLiteralExpression + +final class DateLiteralExpression = Impl::DateLiteralExpression; diff --git a/xpp/ql/lib/codeql/xpp/elements/DateTimeAttributeLiteral.qll b/xpp/ql/lib/codeql/xpp/elements/DateTimeAttributeLiteral.qll new file mode 100644 index 000000000000..de40e487310e --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/DateTimeAttributeLiteral.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `DateTimeAttributeLiteral`. + */ + +private import internal.DateTimeAttributeLiteralImpl +import codeql.xpp.elements.DefaultTypeAttributeLiteral + +final class DateTimeAttributeLiteral = Impl::DateTimeAttributeLiteral; diff --git a/xpp/ql/lib/codeql/xpp/elements/DateTimeLiteralExpression.qll b/xpp/ql/lib/codeql/xpp/elements/DateTimeLiteralExpression.qll new file mode 100644 index 000000000000..9bb8c2cad642 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/DateTimeLiteralExpression.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `DateTimeLiteralExpression`. + */ + +private import internal.DateTimeLiteralExpressionImpl +import codeql.xpp.elements.DefaultTypeLiteralExpression + +final class DateTimeLiteralExpression = Impl::DateTimeLiteralExpression; diff --git a/xpp/ql/lib/codeql/xpp/elements/DateTimeType.qll b/xpp/ql/lib/codeql/xpp/elements/DateTimeType.qll new file mode 100644 index 000000000000..886688b47c5e --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/DateTimeType.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `DateTimeType`. + */ + +private import internal.DateTimeTypeImpl +import codeql.xpp.elements.XppType + +final class DateTimeType = Impl::DateTimeType; diff --git a/xpp/ql/lib/codeql/xpp/elements/DateType.qll b/xpp/ql/lib/codeql/xpp/elements/DateType.qll new file mode 100644 index 000000000000..7dc3d4cb0614 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/DateType.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `DateType`. + */ + +private import internal.DateTypeImpl +import codeql.xpp.elements.XppType + +final class DateType = Impl::DateType; diff --git a/xpp/ql/lib/codeql/xpp/elements/DblAttributeLiteral.qll b/xpp/ql/lib/codeql/xpp/elements/DblAttributeLiteral.qll new file mode 100644 index 000000000000..625ad5fa2d5a --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/DblAttributeLiteral.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `DblAttributeLiteral`. + */ + +private import internal.DblAttributeLiteralImpl +import codeql.xpp.elements.DefaultTypeAttributeLiteral + +final class DblAttributeLiteral = Impl::DblAttributeLiteral; diff --git a/xpp/ql/lib/codeql/xpp/elements/DblType.qll b/xpp/ql/lib/codeql/xpp/elements/DblType.qll new file mode 100644 index 000000000000..9983511b29cd --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/DblType.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `DblType`. + */ + +private import internal.DblTypeImpl +import codeql.xpp.elements.XppType + +final class DblType = Impl::DblType; diff --git a/xpp/ql/lib/codeql/xpp/elements/Declaration.qll b/xpp/ql/lib/codeql/xpp/elements/Declaration.qll new file mode 100644 index 000000000000..29828f5200aa --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/Declaration.qll @@ -0,0 +1,12 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `Declaration`. + */ + +private import internal.DeclarationImpl +import codeql.xpp.elements.ArraySpecification +import codeql.xpp.elements.CompilationUnit +import codeql.xpp.elements.Modifier +import codeql.xpp.elements.XppType + +final class Declaration = Impl::Declaration; diff --git a/xpp/ql/lib/codeql/xpp/elements/DefaultTypeAttributeLiteral.qll b/xpp/ql/lib/codeql/xpp/elements/DefaultTypeAttributeLiteral.qll new file mode 100644 index 000000000000..f352dfe9b1ca --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/DefaultTypeAttributeLiteral.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `DefaultTypeAttributeLiteral`. + */ + +private import internal.DefaultTypeAttributeLiteralImpl +import codeql.xpp.elements.AttributeLiteral + +final class DefaultTypeAttributeLiteral = Impl::DefaultTypeAttributeLiteral; diff --git a/xpp/ql/lib/codeql/xpp/elements/DefaultTypeLiteralExpression.qll b/xpp/ql/lib/codeql/xpp/elements/DefaultTypeLiteralExpression.qll new file mode 100644 index 000000000000..9cd6ff291db8 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/DefaultTypeLiteralExpression.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `DefaultTypeLiteralExpression`. + */ + +private import internal.DefaultTypeLiteralExpressionImpl +import codeql.xpp.elements.LiteralExpression + +final class DefaultTypeLiteralExpression = Impl::DefaultTypeLiteralExpression; diff --git a/xpp/ql/lib/codeql/xpp/elements/Delegate.qll b/xpp/ql/lib/codeql/xpp/elements/Delegate.qll new file mode 100644 index 000000000000..73dcc33b0da4 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/Delegate.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `Delegate`. + */ + +private import internal.DelegateImpl +import codeql.xpp.elements.MethodOrDelegate + +final class Delegate = Impl::Delegate; diff --git a/xpp/ql/lib/codeql/xpp/elements/DeleteStatement.qll b/xpp/ql/lib/codeql/xpp/elements/DeleteStatement.qll new file mode 100644 index 000000000000..2565814229b4 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/DeleteStatement.qll @@ -0,0 +1,10 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `DeleteStatement`. + */ + +private import internal.DeleteStatementImpl +import codeql.xpp.elements.Query +import codeql.xpp.elements.Statement + +final class DeleteStatement = Impl::DeleteStatement; diff --git a/xpp/ql/lib/codeql/xpp/elements/DivideExpression.qll b/xpp/ql/lib/codeql/xpp/elements/DivideExpression.qll new file mode 100644 index 000000000000..2e32ee0b98e4 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/DivideExpression.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `DivideExpression`. + */ + +private import internal.DivideExpressionImpl +import codeql.xpp.elements.BinaryExpression + +final class DivideExpression = Impl::DivideExpression; diff --git a/xpp/ql/lib/codeql/xpp/elements/DoWhileStatement.qll b/xpp/ql/lib/codeql/xpp/elements/DoWhileStatement.qll new file mode 100644 index 000000000000..00a85dce26cf --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/DoWhileStatement.qll @@ -0,0 +1,10 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `DoWhileStatement`. + */ + +private import internal.DoWhileStatementImpl +import codeql.xpp.elements.Expression +import codeql.xpp.elements.Statement + +final class DoWhileStatement = Impl::DoWhileStatement; diff --git a/xpp/ql/lib/codeql/xpp/elements/Element.qll b/xpp/ql/lib/codeql/xpp/elements/Element.qll new file mode 100644 index 000000000000..c16bd596a87d --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/Element.qll @@ -0,0 +1,8 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `Element`. + */ + +private import internal.ElementImpl + +final class Element = Impl::Element; diff --git a/xpp/ql/lib/codeql/xpp/elements/EmptyExpression.qll b/xpp/ql/lib/codeql/xpp/elements/EmptyExpression.qll new file mode 100644 index 000000000000..09fd19431f4b --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/EmptyExpression.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `EmptyExpression`. + */ + +private import internal.EmptyExpressionImpl +import codeql.xpp.elements.Expression + +final class EmptyExpression = Impl::EmptyExpression; diff --git a/xpp/ql/lib/codeql/xpp/elements/EmptyStatement.qll b/xpp/ql/lib/codeql/xpp/elements/EmptyStatement.qll new file mode 100644 index 000000000000..640577aee2d4 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/EmptyStatement.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `EmptyStatement`. + */ + +private import internal.EmptyStatementImpl +import codeql.xpp.elements.Statement + +final class EmptyStatement = Impl::EmptyStatement; diff --git a/xpp/ql/lib/codeql/xpp/elements/EnumAttributeLiteral.qll b/xpp/ql/lib/codeql/xpp/elements/EnumAttributeLiteral.qll new file mode 100644 index 000000000000..a154cfd9b10c --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/EnumAttributeLiteral.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `EnumAttributeLiteral`. + */ + +private import internal.EnumAttributeLiteralImpl +import codeql.xpp.elements.AttributeLiteral + +final class EnumAttributeLiteral = Impl::EnumAttributeLiteral; diff --git a/xpp/ql/lib/codeql/xpp/elements/EnumerationLiteralExpression.qll b/xpp/ql/lib/codeql/xpp/elements/EnumerationLiteralExpression.qll new file mode 100644 index 000000000000..9c12187e8541 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/EnumerationLiteralExpression.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `EnumerationLiteralExpression`. + */ + +private import internal.EnumerationLiteralExpressionImpl +import codeql.xpp.elements.LiteralExpression + +final class EnumerationLiteralExpression = Impl::EnumerationLiteralExpression; diff --git a/xpp/ql/lib/codeql/xpp/elements/EnumerationType.qll b/xpp/ql/lib/codeql/xpp/elements/EnumerationType.qll new file mode 100644 index 000000000000..c2c44de09676 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/EnumerationType.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `EnumerationType`. + */ + +private import internal.EnumerationTypeImpl +import codeql.xpp.elements.XppType + +final class EnumerationType = Impl::EnumerationType; diff --git a/xpp/ql/lib/codeql/xpp/elements/EqualExpression.qll b/xpp/ql/lib/codeql/xpp/elements/EqualExpression.qll new file mode 100644 index 000000000000..c07fd6b20a88 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/EqualExpression.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `EqualExpression`. + */ + +private import internal.EqualExpressionImpl +import codeql.xpp.elements.RelationalExpression + +final class EqualExpression = Impl::EqualExpression; diff --git a/xpp/ql/lib/codeql/xpp/elements/ErrorElement.qll b/xpp/ql/lib/codeql/xpp/elements/ErrorElement.qll new file mode 100644 index 000000000000..3327765b5b90 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/ErrorElement.qll @@ -0,0 +1,12 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `ErrorElement`. + */ + +private import internal.ErrorElementImpl +import codeql.xpp.elements.Locatable + +/** + * The superclass of all elements indicating some kind of error. + */ +final class ErrorElement = Impl::ErrorElement; diff --git a/xpp/ql/lib/codeql/xpp/elements/Evaluation.qll b/xpp/ql/lib/codeql/xpp/elements/Evaluation.qll new file mode 100644 index 000000000000..76431b6ecc01 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/Evaluation.qll @@ -0,0 +1,10 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `Evaluation`. + */ + +private import internal.EvaluationImpl +import codeql.xpp.elements.EvaluationActualParameterEntry +import codeql.xpp.elements.Expression + +final class Evaluation = Impl::Evaluation; diff --git a/xpp/ql/lib/codeql/xpp/elements/EvaluationActualParameterEntry.qll b/xpp/ql/lib/codeql/xpp/elements/EvaluationActualParameterEntry.qll new file mode 100644 index 000000000000..be63e31f7b6f --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/EvaluationActualParameterEntry.qll @@ -0,0 +1,10 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `EvaluationActualParameterEntry`. + */ + +private import internal.EvaluationActualParameterEntryImpl +import codeql.xpp.elements.Expression +import codeql.xpp.elements.XppTuple + +final class EvaluationActualParameterEntry = Impl::EvaluationActualParameterEntry; diff --git a/xpp/ql/lib/codeql/xpp/elements/ExplicitSelection.qll b/xpp/ql/lib/codeql/xpp/elements/ExplicitSelection.qll new file mode 100644 index 000000000000..58be8e189e99 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/ExplicitSelection.qll @@ -0,0 +1,10 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `ExplicitSelection`. + */ + +private import internal.ExplicitSelectionImpl +import codeql.xpp.elements.Selection +import codeql.xpp.elements.SelectionField + +final class ExplicitSelection = Impl::ExplicitSelection; diff --git a/xpp/ql/lib/codeql/xpp/elements/Expression.qll b/xpp/ql/lib/codeql/xpp/elements/Expression.qll new file mode 100644 index 000000000000..34a47dfd6c53 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/Expression.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `Expression`. + */ + +private import internal.ExpressionImpl +import codeql.xpp.elements.Ast + +final class Expression = Impl::Expression; diff --git a/xpp/ql/lib/codeql/xpp/elements/ExpressionCompilationUnit.qll b/xpp/ql/lib/codeql/xpp/elements/ExpressionCompilationUnit.qll new file mode 100644 index 000000000000..2c691cb41661 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/ExpressionCompilationUnit.qll @@ -0,0 +1,10 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `ExpressionCompilationUnit`. + */ + +private import internal.ExpressionCompilationUnitImpl +import codeql.xpp.elements.CompilationUnit +import codeql.xpp.elements.Expression + +final class ExpressionCompilationUnit = Impl::ExpressionCompilationUnit; diff --git a/xpp/ql/lib/codeql/xpp/elements/ExpressionQualifier.qll b/xpp/ql/lib/codeql/xpp/elements/ExpressionQualifier.qll new file mode 100644 index 000000000000..09be4a0c8e76 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/ExpressionQualifier.qll @@ -0,0 +1,10 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `ExpressionQualifier`. + */ + +private import internal.ExpressionQualifierImpl +import codeql.xpp.elements.Expression +import codeql.xpp.elements.Qualifier + +final class ExpressionQualifier = Impl::ExpressionQualifier; diff --git a/xpp/ql/lib/codeql/xpp/elements/ExpressionStatement.qll b/xpp/ql/lib/codeql/xpp/elements/ExpressionStatement.qll new file mode 100644 index 000000000000..e50f486284ee --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/ExpressionStatement.qll @@ -0,0 +1,10 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `ExpressionStatement`. + */ + +private import internal.ExpressionStatementImpl +import codeql.xpp.elements.Expression +import codeql.xpp.elements.Statement + +final class ExpressionStatement = Impl::ExpressionStatement; diff --git a/xpp/ql/lib/codeql/xpp/elements/FieldAssignment.qll b/xpp/ql/lib/codeql/xpp/elements/FieldAssignment.qll new file mode 100644 index 000000000000..3431b73e3a38 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/FieldAssignment.qll @@ -0,0 +1,10 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `FieldAssignment`. + */ + +private import internal.FieldAssignmentImpl +import codeql.xpp.elements.Ast +import codeql.xpp.elements.Expression + +final class FieldAssignment = Impl::FieldAssignment; diff --git a/xpp/ql/lib/codeql/xpp/elements/FieldDeclaration.qll b/xpp/ql/lib/codeql/xpp/elements/FieldDeclaration.qll new file mode 100644 index 000000000000..172a0c2a8356 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/FieldDeclaration.qll @@ -0,0 +1,11 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `FieldDeclaration`. + */ + +private import internal.FieldDeclarationImpl +import codeql.xpp.elements.AttributeList +import codeql.xpp.elements.Declaration +import codeql.xpp.elements.Expression + +final class FieldDeclaration = Impl::FieldDeclaration; diff --git a/xpp/ql/lib/codeql/xpp/elements/FieldDeclarationInternal.qll b/xpp/ql/lib/codeql/xpp/elements/FieldDeclarationInternal.qll new file mode 100644 index 000000000000..2a40e71162fc --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/FieldDeclarationInternal.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `FieldDeclarationInternal`. + */ + +private import internal.FieldDeclarationInternalImpl +import codeql.xpp.elements.FieldDeclaration + +final class FieldDeclarationInternal = Impl::FieldDeclarationInternal; diff --git a/xpp/ql/lib/codeql/xpp/elements/FieldExpression.qll b/xpp/ql/lib/codeql/xpp/elements/FieldExpression.qll new file mode 100644 index 000000000000..24f1fa8fa7a6 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/FieldExpression.qll @@ -0,0 +1,10 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `FieldExpression`. + */ + +private import internal.FieldExpressionImpl +import codeql.xpp.elements.Expression +import codeql.xpp.elements.FieldSpecification + +final class FieldExpression = Impl::FieldExpression; diff --git a/xpp/ql/lib/codeql/xpp/elements/FieldExpressionInternal.qll b/xpp/ql/lib/codeql/xpp/elements/FieldExpressionInternal.qll new file mode 100644 index 000000000000..af9b5c67d0ae --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/FieldExpressionInternal.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `FieldExpressionInternal`. + */ + +private import internal.FieldExpressionInternalImpl +import codeql.xpp.elements.FieldExpression + +final class FieldExpressionInternal = Impl::FieldExpressionInternal; diff --git a/xpp/ql/lib/codeql/xpp/elements/FieldSelection.qll b/xpp/ql/lib/codeql/xpp/elements/FieldSelection.qll new file mode 100644 index 000000000000..31e14b8f4929 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/FieldSelection.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `FieldSelection`. + */ + +private import internal.FieldSelectionImpl +import codeql.xpp.elements.SelectionField + +final class FieldSelection = Impl::FieldSelection; diff --git a/xpp/ql/lib/codeql/xpp/elements/FieldSpecification.qll b/xpp/ql/lib/codeql/xpp/elements/FieldSpecification.qll new file mode 100644 index 000000000000..d6c7e81b11b3 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/FieldSpecification.qll @@ -0,0 +1,11 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `FieldSpecification`. + */ + +private import internal.FieldSpecificationImpl +import codeql.xpp.elements.Ast +import codeql.xpp.elements.Expression +import codeql.xpp.elements.Qualifier + +final class FieldSpecification = Impl::FieldSpecification; diff --git a/xpp/ql/lib/codeql/xpp/elements/File.qll b/xpp/ql/lib/codeql/xpp/elements/File.qll new file mode 100644 index 000000000000..df5d6904e80d --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/File.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `File`. + */ + +private import internal.FileImpl +import codeql.xpp.elements.Element + +final class File = Impl::File; diff --git a/xpp/ql/lib/codeql/xpp/elements/FindStatement.qll b/xpp/ql/lib/codeql/xpp/elements/FindStatement.qll new file mode 100644 index 000000000000..697e01cf6076 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/FindStatement.qll @@ -0,0 +1,10 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `FindStatement`. + */ + +private import internal.FindStatementImpl +import codeql.xpp.elements.Query +import codeql.xpp.elements.Statement + +final class FindStatement = Impl::FindStatement; diff --git a/xpp/ql/lib/codeql/xpp/elements/FlushStatement.qll b/xpp/ql/lib/codeql/xpp/elements/FlushStatement.qll new file mode 100644 index 000000000000..20ea67a9b1b7 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/FlushStatement.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `FlushStatement`. + */ + +private import internal.FlushStatementImpl +import codeql.xpp.elements.Statement + +final class FlushStatement = Impl::FlushStatement; diff --git a/xpp/ql/lib/codeql/xpp/elements/ForAssign.qll b/xpp/ql/lib/codeql/xpp/elements/ForAssign.qll new file mode 100644 index 000000000000..63c43af227fd --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/ForAssign.qll @@ -0,0 +1,10 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `ForAssign`. + */ + +private import internal.ForAssignImpl +import codeql.xpp.elements.Ast +import codeql.xpp.elements.FieldSpecification + +final class ForAssign = Impl::ForAssign; diff --git a/xpp/ql/lib/codeql/xpp/elements/ForDeclarationAssign.qll b/xpp/ql/lib/codeql/xpp/elements/ForDeclarationAssign.qll new file mode 100644 index 000000000000..1eb8a752de32 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/ForDeclarationAssign.qll @@ -0,0 +1,10 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `ForDeclarationAssign`. + */ + +private import internal.ForDeclarationAssignImpl +import codeql.xpp.elements.ForAssign +import codeql.xpp.elements.VariableDeclaration + +final class ForDeclarationAssign = Impl::ForDeclarationAssign; diff --git a/xpp/ql/lib/codeql/xpp/elements/ForExpressionAssign.qll b/xpp/ql/lib/codeql/xpp/elements/ForExpressionAssign.qll new file mode 100644 index 000000000000..c10bbec2c8c7 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/ForExpressionAssign.qll @@ -0,0 +1,10 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `ForExpressionAssign`. + */ + +private import internal.ForExpressionAssignImpl +import codeql.xpp.elements.Expression +import codeql.xpp.elements.ForAssign + +final class ForExpressionAssign = Impl::ForExpressionAssign; diff --git a/xpp/ql/lib/codeql/xpp/elements/ForFieldAssign.qll b/xpp/ql/lib/codeql/xpp/elements/ForFieldAssign.qll new file mode 100644 index 000000000000..5108c718dfac --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/ForFieldAssign.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `ForFieldAssign`. + */ + +private import internal.ForFieldAssignImpl +import codeql.xpp.elements.ForExpressionAssign + +final class ForFieldAssign = Impl::ForFieldAssign; diff --git a/xpp/ql/lib/codeql/xpp/elements/ForFieldDecrementAssign.qll b/xpp/ql/lib/codeql/xpp/elements/ForFieldDecrementAssign.qll new file mode 100644 index 000000000000..a81f9b15cd5e --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/ForFieldDecrementAssign.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `ForFieldDecrementAssign`. + */ + +private import internal.ForFieldDecrementAssignImpl +import codeql.xpp.elements.ForExpressionAssign + +final class ForFieldDecrementAssign = Impl::ForFieldDecrementAssign; diff --git a/xpp/ql/lib/codeql/xpp/elements/ForFieldIncrementAssign.qll b/xpp/ql/lib/codeql/xpp/elements/ForFieldIncrementAssign.qll new file mode 100644 index 000000000000..04f2fb35c1c0 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/ForFieldIncrementAssign.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `ForFieldIncrementAssign`. + */ + +private import internal.ForFieldIncrementAssignImpl +import codeql.xpp.elements.ForExpressionAssign + +final class ForFieldIncrementAssign = Impl::ForFieldIncrementAssign; diff --git a/xpp/ql/lib/codeql/xpp/elements/ForFieldPostDecrement.qll b/xpp/ql/lib/codeql/xpp/elements/ForFieldPostDecrement.qll new file mode 100644 index 000000000000..b106f451ea01 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/ForFieldPostDecrement.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `ForFieldPostDecrement`. + */ + +private import internal.ForFieldPostDecrementImpl +import codeql.xpp.elements.ForAssign + +final class ForFieldPostDecrement = Impl::ForFieldPostDecrement; diff --git a/xpp/ql/lib/codeql/xpp/elements/ForFieldPostIncrement.qll b/xpp/ql/lib/codeql/xpp/elements/ForFieldPostIncrement.qll new file mode 100644 index 000000000000..9a1a2f7eeefa --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/ForFieldPostIncrement.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `ForFieldPostIncrement`. + */ + +private import internal.ForFieldPostIncrementImpl +import codeql.xpp.elements.ForAssign + +final class ForFieldPostIncrement = Impl::ForFieldPostIncrement; diff --git a/xpp/ql/lib/codeql/xpp/elements/ForFieldPreDecrement.qll b/xpp/ql/lib/codeql/xpp/elements/ForFieldPreDecrement.qll new file mode 100644 index 000000000000..f64c3c33c666 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/ForFieldPreDecrement.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `ForFieldPreDecrement`. + */ + +private import internal.ForFieldPreDecrementImpl +import codeql.xpp.elements.ForAssign + +final class ForFieldPreDecrement = Impl::ForFieldPreDecrement; diff --git a/xpp/ql/lib/codeql/xpp/elements/ForFieldPreIncrement.qll b/xpp/ql/lib/codeql/xpp/elements/ForFieldPreIncrement.qll new file mode 100644 index 000000000000..5d1988ddbb92 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/ForFieldPreIncrement.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `ForFieldPreIncrement`. + */ + +private import internal.ForFieldPreIncrementImpl +import codeql.xpp.elements.ForAssign + +final class ForFieldPreIncrement = Impl::ForFieldPreIncrement; diff --git a/xpp/ql/lib/codeql/xpp/elements/ForStatement.qll b/xpp/ql/lib/codeql/xpp/elements/ForStatement.qll new file mode 100644 index 000000000000..018740bab935 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/ForStatement.qll @@ -0,0 +1,11 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `ForStatement`. + */ + +private import internal.ForStatementImpl +import codeql.xpp.elements.Expression +import codeql.xpp.elements.ForAssign +import codeql.xpp.elements.Statement + +final class ForStatement = Impl::ForStatement; diff --git a/xpp/ql/lib/codeql/xpp/elements/FormControl.qll b/xpp/ql/lib/codeql/xpp/elements/FormControl.qll new file mode 100644 index 000000000000..a024567d0dee --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/FormControl.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `FormControl`. + */ + +private import internal.FormControlImpl +import codeql.xpp.elements.FormNestedElement + +final class FormControl = Impl::FormControl; diff --git a/xpp/ql/lib/codeql/xpp/elements/FormDataField.qll b/xpp/ql/lib/codeql/xpp/elements/FormDataField.qll new file mode 100644 index 000000000000..3695806e72e2 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/FormDataField.qll @@ -0,0 +1,10 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `FormDataField`. + */ + +private import internal.FormDataFieldImpl +import codeql.xpp.elements.FormDataSource +import codeql.xpp.elements.FormNestedElement + +final class FormDataField = Impl::FormDataField; diff --git a/xpp/ql/lib/codeql/xpp/elements/FormDataSource.qll b/xpp/ql/lib/codeql/xpp/elements/FormDataSource.qll new file mode 100644 index 000000000000..60f10675e52f --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/FormDataSource.qll @@ -0,0 +1,11 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `FormDataSource`. + */ + +private import internal.FormDataSourceImpl +import codeql.xpp.elements.FormDataField +import codeql.xpp.elements.FormNestedElement +import codeql.xpp.elements.QueryModelElement + +final class FormDataSource = Impl::FormDataSource; diff --git a/xpp/ql/lib/codeql/xpp/elements/FormElementType.qll b/xpp/ql/lib/codeql/xpp/elements/FormElementType.qll new file mode 100644 index 000000000000..0f09fdcad2c2 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/FormElementType.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `FormElementType`. + */ + +private import internal.FormElementTypeImpl +import codeql.xpp.elements.NamedType + +final class FormElementType = Impl::FormElementType; diff --git a/xpp/ql/lib/codeql/xpp/elements/FormModelElement.qll b/xpp/ql/lib/codeql/xpp/elements/FormModelElement.qll new file mode 100644 index 000000000000..33ac5eabae4d --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/FormModelElement.qll @@ -0,0 +1,12 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `FormModelElement`. + */ + +private import internal.FormModelElementImpl +import codeql.xpp.elements.Class +import codeql.xpp.elements.FormControl +import codeql.xpp.elements.FormDataSource +import codeql.xpp.elements.ModelElement + +final class FormModelElement = Impl::FormModelElement; diff --git a/xpp/ql/lib/codeql/xpp/elements/FormNestedElement.qll b/xpp/ql/lib/codeql/xpp/elements/FormNestedElement.qll new file mode 100644 index 000000000000..924479cbac8e --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/FormNestedElement.qll @@ -0,0 +1,10 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `FormNestedElement`. + */ + +private import internal.FormNestedElementImpl +import codeql.xpp.elements.FormModelElement +import codeql.xpp.elements.ModelElement + +final class FormNestedElement = Impl::FormNestedElement; diff --git a/xpp/ql/lib/codeql/xpp/elements/FunctionCall.qll b/xpp/ql/lib/codeql/xpp/elements/FunctionCall.qll new file mode 100644 index 000000000000..2fbb999b8baa --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/FunctionCall.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `FunctionCall`. + */ + +private import internal.FunctionCallImpl +import codeql.xpp.elements.GenericEvaluation + +final class FunctionCall = Impl::FunctionCall; diff --git a/xpp/ql/lib/codeql/xpp/elements/FunctionDeclaration.qll b/xpp/ql/lib/codeql/xpp/elements/FunctionDeclaration.qll new file mode 100644 index 000000000000..5ad20167d36e --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/FunctionDeclaration.qll @@ -0,0 +1,11 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `FunctionDeclaration`. + */ + +private import internal.FunctionDeclarationImpl +import codeql.xpp.elements.LocalDeclaration +import codeql.xpp.elements.ParameterDeclaration +import codeql.xpp.elements.Statement + +final class FunctionDeclaration = Impl::FunctionDeclaration; diff --git a/xpp/ql/lib/codeql/xpp/elements/GenericEvaluation.qll b/xpp/ql/lib/codeql/xpp/elements/GenericEvaluation.qll new file mode 100644 index 000000000000..d64ed2df7d1e --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/GenericEvaluation.qll @@ -0,0 +1,10 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `GenericEvaluation`. + */ + +private import internal.GenericEvaluationImpl +import codeql.xpp.elements.Evaluation +import codeql.xpp.elements.XppType + +final class GenericEvaluation = Impl::GenericEvaluation; diff --git a/xpp/ql/lib/codeql/xpp/elements/GenericXppType.qll b/xpp/ql/lib/codeql/xpp/elements/GenericXppType.qll new file mode 100644 index 000000000000..1d7694721452 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/GenericXppType.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `GenericXppType`. + */ + +private import internal.GenericXppTypeImpl +import codeql.xpp.elements.XppType + +final class GenericXppType = Impl::GenericXppType; diff --git a/xpp/ql/lib/codeql/xpp/elements/GlobalOrderElement.qll b/xpp/ql/lib/codeql/xpp/elements/GlobalOrderElement.qll new file mode 100644 index 000000000000..d15f66a0dd3c --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/GlobalOrderElement.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `GlobalOrderElement`. + */ + +private import internal.GlobalOrderElementImpl +import codeql.xpp.elements.OrderElement + +final class GlobalOrderElement = Impl::GlobalOrderElement; diff --git a/xpp/ql/lib/codeql/xpp/elements/GreaterThanExpression.qll b/xpp/ql/lib/codeql/xpp/elements/GreaterThanExpression.qll new file mode 100644 index 000000000000..29eedc668645 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/GreaterThanExpression.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `GreaterThanExpression`. + */ + +private import internal.GreaterThanExpressionImpl +import codeql.xpp.elements.RelationalExpression + +final class GreaterThanExpression = Impl::GreaterThanExpression; diff --git a/xpp/ql/lib/codeql/xpp/elements/GreaterThanOrEqualExpression.qll b/xpp/ql/lib/codeql/xpp/elements/GreaterThanOrEqualExpression.qll new file mode 100644 index 000000000000..d4da1d435c2e --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/GreaterThanOrEqualExpression.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `GreaterThanOrEqualExpression`. + */ + +private import internal.GreaterThanOrEqualExpressionImpl +import codeql.xpp.elements.RelationalExpression + +final class GreaterThanOrEqualExpression = Impl::GreaterThanOrEqualExpression; diff --git a/xpp/ql/lib/codeql/xpp/elements/GuidAttributeLiteral.qll b/xpp/ql/lib/codeql/xpp/elements/GuidAttributeLiteral.qll new file mode 100644 index 000000000000..58c6161e0a36 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/GuidAttributeLiteral.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `GuidAttributeLiteral`. + */ + +private import internal.GuidAttributeLiteralImpl +import codeql.xpp.elements.DefaultTypeAttributeLiteral + +final class GuidAttributeLiteral = Impl::GuidAttributeLiteral; diff --git a/xpp/ql/lib/codeql/xpp/elements/GuidType.qll b/xpp/ql/lib/codeql/xpp/elements/GuidType.qll new file mode 100644 index 000000000000..da19c79fe4aa --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/GuidType.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `GuidType`. + */ + +private import internal.GuidTypeImpl +import codeql.xpp.elements.XppType + +final class GuidType = Impl::GuidType; diff --git a/xpp/ql/lib/codeql/xpp/elements/IfStatement.qll b/xpp/ql/lib/codeql/xpp/elements/IfStatement.qll new file mode 100644 index 000000000000..9b754d003cba --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/IfStatement.qll @@ -0,0 +1,10 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `IfStatement`. + */ + +private import internal.IfStatementImpl +import codeql.xpp.elements.Expression +import codeql.xpp.elements.Statement + +final class IfStatement = Impl::IfStatement; diff --git a/xpp/ql/lib/codeql/xpp/elements/IfThenElseStatement.qll b/xpp/ql/lib/codeql/xpp/elements/IfThenElseStatement.qll new file mode 100644 index 000000000000..ab5d0df3bfdd --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/IfThenElseStatement.qll @@ -0,0 +1,10 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `IfThenElseStatement`. + */ + +private import internal.IfThenElseStatementImpl +import codeql.xpp.elements.Expression +import codeql.xpp.elements.Statement + +final class IfThenElseStatement = Impl::IfThenElseStatement; diff --git a/xpp/ql/lib/codeql/xpp/elements/ImplicitSelection.qll b/xpp/ql/lib/codeql/xpp/elements/ImplicitSelection.qll new file mode 100644 index 000000000000..edc0754406a9 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/ImplicitSelection.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `ImplicitSelection`. + */ + +private import internal.ImplicitSelectionImpl +import codeql.xpp.elements.Selection + +final class ImplicitSelection = Impl::ImplicitSelection; diff --git a/xpp/ql/lib/codeql/xpp/elements/InExpression.qll b/xpp/ql/lib/codeql/xpp/elements/InExpression.qll new file mode 100644 index 000000000000..6e2a7f4bc76c --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/InExpression.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `InExpression`. + */ + +private import internal.InExpressionImpl +import codeql.xpp.elements.BinaryExpression + +final class InExpression = Impl::InExpression; diff --git a/xpp/ql/lib/codeql/xpp/elements/InsertFieldSpecification.qll b/xpp/ql/lib/codeql/xpp/elements/InsertFieldSpecification.qll new file mode 100644 index 000000000000..29d36bd4e1e0 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/InsertFieldSpecification.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `InsertFieldSpecification`. + */ + +private import internal.InsertFieldSpecificationImpl +import codeql.xpp.elements.Ast + +final class InsertFieldSpecification = Impl::InsertFieldSpecification; diff --git a/xpp/ql/lib/codeql/xpp/elements/InsertStatement.qll b/xpp/ql/lib/codeql/xpp/elements/InsertStatement.qll new file mode 100644 index 000000000000..9e686d4d28e6 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/InsertStatement.qll @@ -0,0 +1,12 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `InsertStatement`. + */ + +private import internal.InsertStatementImpl +import codeql.xpp.elements.CrossCompany +import codeql.xpp.elements.InsertFieldSpecification +import codeql.xpp.elements.Query +import codeql.xpp.elements.Statement + +final class InsertStatement = Impl::InsertStatement; diff --git a/xpp/ql/lib/codeql/xpp/elements/InstanceName.qll b/xpp/ql/lib/codeql/xpp/elements/InstanceName.qll new file mode 100644 index 000000000000..fcf166640898 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/InstanceName.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `InstanceName`. + */ + +private import internal.InstanceNameImpl +import codeql.xpp.elements.Ast + +final class InstanceName = Impl::InstanceName; diff --git a/xpp/ql/lib/codeql/xpp/elements/Int64AttributeLiteral.qll b/xpp/ql/lib/codeql/xpp/elements/Int64AttributeLiteral.qll new file mode 100644 index 000000000000..f5da4c93e300 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/Int64AttributeLiteral.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `Int64AttributeLiteral`. + */ + +private import internal.Int64AttributeLiteralImpl +import codeql.xpp.elements.DefaultTypeAttributeLiteral + +final class Int64AttributeLiteral = Impl::Int64AttributeLiteral; diff --git a/xpp/ql/lib/codeql/xpp/elements/Int64LiteralExpression.qll b/xpp/ql/lib/codeql/xpp/elements/Int64LiteralExpression.qll new file mode 100644 index 000000000000..5e00fdbdaf60 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/Int64LiteralExpression.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `Int64LiteralExpression`. + */ + +private import internal.Int64LiteralExpressionImpl +import codeql.xpp.elements.DefaultTypeLiteralExpression + +final class Int64LiteralExpression = Impl::Int64LiteralExpression; diff --git a/xpp/ql/lib/codeql/xpp/elements/Int64Type.qll b/xpp/ql/lib/codeql/xpp/elements/Int64Type.qll new file mode 100644 index 000000000000..074b670e8ba1 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/Int64Type.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `Int64Type`. + */ + +private import internal.Int64TypeImpl +import codeql.xpp.elements.XppType + +final class Int64Type = Impl::Int64Type; diff --git a/xpp/ql/lib/codeql/xpp/elements/IntAttributeLiteral.qll b/xpp/ql/lib/codeql/xpp/elements/IntAttributeLiteral.qll new file mode 100644 index 000000000000..e9581f59d731 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/IntAttributeLiteral.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `IntAttributeLiteral`. + */ + +private import internal.IntAttributeLiteralImpl +import codeql.xpp.elements.DefaultTypeAttributeLiteral + +final class IntAttributeLiteral = Impl::IntAttributeLiteral; diff --git a/xpp/ql/lib/codeql/xpp/elements/IntLiteralExpression.qll b/xpp/ql/lib/codeql/xpp/elements/IntLiteralExpression.qll new file mode 100644 index 000000000000..5903ef1bbcde --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/IntLiteralExpression.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `IntLiteralExpression`. + */ + +private import internal.IntLiteralExpressionImpl +import codeql.xpp.elements.DefaultTypeLiteralExpression + +final class IntLiteralExpression = Impl::IntLiteralExpression; diff --git a/xpp/ql/lib/codeql/xpp/elements/IntType.qll b/xpp/ql/lib/codeql/xpp/elements/IntType.qll new file mode 100644 index 000000000000..e85a3a69b0f4 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/IntType.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `IntType`. + */ + +private import internal.IntTypeImpl +import codeql.xpp.elements.XppType + +final class IntType = Impl::IntType; diff --git a/xpp/ql/lib/codeql/xpp/elements/IntegerDivideExpression.qll b/xpp/ql/lib/codeql/xpp/elements/IntegerDivideExpression.qll new file mode 100644 index 000000000000..95a26fdf14d6 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/IntegerDivideExpression.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `IntegerDivideExpression`. + */ + +private import internal.IntegerDivideExpressionImpl +import codeql.xpp.elements.BinaryExpression + +final class IntegerDivideExpression = Impl::IntegerDivideExpression; diff --git a/xpp/ql/lib/codeql/xpp/elements/Interface.qll b/xpp/ql/lib/codeql/xpp/elements/Interface.qll new file mode 100644 index 000000000000..ffd461886fce --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/Interface.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `Interface`. + */ + +private import internal.InterfaceImpl +import codeql.xpp.elements.ClassOrInterface + +final class Interface = Impl::Interface; diff --git a/xpp/ql/lib/codeql/xpp/elements/Intrinsic.qll b/xpp/ql/lib/codeql/xpp/elements/Intrinsic.qll new file mode 100644 index 000000000000..1513a191b2e0 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/Intrinsic.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `Intrinsic`. + */ + +private import internal.IntrinsicImpl +import codeql.xpp.elements.Expression + +final class Intrinsic = Impl::Intrinsic; diff --git a/xpp/ql/lib/codeql/xpp/elements/IntrinsicAttributeLiteral.qll b/xpp/ql/lib/codeql/xpp/elements/IntrinsicAttributeLiteral.qll new file mode 100644 index 000000000000..5b36f02ff889 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/IntrinsicAttributeLiteral.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `IntrinsicAttributeLiteral`. + */ + +private import internal.IntrinsicAttributeLiteralImpl +import codeql.xpp.elements.AttributeLiteral + +final class IntrinsicAttributeLiteral = Impl::IntrinsicAttributeLiteral; diff --git a/xpp/ql/lib/codeql/xpp/elements/IsAsExpression.qll b/xpp/ql/lib/codeql/xpp/elements/IsAsExpression.qll new file mode 100644 index 000000000000..0dc7a7f6a0e4 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/IsAsExpression.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `IsAsExpression`. + */ + +private import internal.IsAsExpressionImpl +import codeql.xpp.elements.Expression + +final class IsAsExpression = Impl::IsAsExpression; diff --git a/xpp/ql/lib/codeql/xpp/elements/IsClrExpression.qll b/xpp/ql/lib/codeql/xpp/elements/IsClrExpression.qll new file mode 100644 index 000000000000..4d7da7df3f61 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/IsClrExpression.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `IsClrExpression`. + */ + +private import internal.IsClrExpressionImpl +import codeql.xpp.elements.IsAsExpression + +final class IsClrExpression = Impl::IsClrExpression; diff --git a/xpp/ql/lib/codeql/xpp/elements/IsExpression.qll b/xpp/ql/lib/codeql/xpp/elements/IsExpression.qll new file mode 100644 index 000000000000..23435dd3b2ea --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/IsExpression.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `IsExpression`. + */ + +private import internal.IsExpressionImpl +import codeql.xpp.elements.IsAsExpression + +final class IsExpression = Impl::IsExpression; diff --git a/xpp/ql/lib/codeql/xpp/elements/JoinSpecification.qll b/xpp/ql/lib/codeql/xpp/elements/JoinSpecification.qll new file mode 100644 index 000000000000..ca8a70384f49 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/JoinSpecification.qll @@ -0,0 +1,10 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `JoinSpecification`. + */ + +private import internal.JoinSpecificationImpl +import codeql.xpp.elements.Ast +import codeql.xpp.elements.Query + +final class JoinSpecification = Impl::JoinSpecification; diff --git a/xpp/ql/lib/codeql/xpp/elements/LessThanExpression.qll b/xpp/ql/lib/codeql/xpp/elements/LessThanExpression.qll new file mode 100644 index 000000000000..5c344ef7d009 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/LessThanExpression.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `LessThanExpression`. + */ + +private import internal.LessThanExpressionImpl +import codeql.xpp.elements.RelationalExpression + +final class LessThanExpression = Impl::LessThanExpression; diff --git a/xpp/ql/lib/codeql/xpp/elements/LessThanOrEqualExpression.qll b/xpp/ql/lib/codeql/xpp/elements/LessThanOrEqualExpression.qll new file mode 100644 index 000000000000..f71cb778556e --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/LessThanOrEqualExpression.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `LessThanOrEqualExpression`. + */ + +private import internal.LessThanOrEqualExpressionImpl +import codeql.xpp.elements.RelationalExpression + +final class LessThanOrEqualExpression = Impl::LessThanOrEqualExpression; diff --git a/xpp/ql/lib/codeql/xpp/elements/LikeExpression.qll b/xpp/ql/lib/codeql/xpp/elements/LikeExpression.qll new file mode 100644 index 000000000000..d9666b11adc8 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/LikeExpression.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `LikeExpression`. + */ + +private import internal.LikeExpressionImpl +import codeql.xpp.elements.RelationalExpression + +final class LikeExpression = Impl::LikeExpression; diff --git a/xpp/ql/lib/codeql/xpp/elements/LiteralExpression.qll b/xpp/ql/lib/codeql/xpp/elements/LiteralExpression.qll new file mode 100644 index 000000000000..8cf1151efe90 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/LiteralExpression.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `LiteralExpression`. + */ + +private import internal.LiteralExpressionImpl +import codeql.xpp.elements.Expression + +final class LiteralExpression = Impl::LiteralExpression; diff --git a/xpp/ql/lib/codeql/xpp/elements/LocalDeclaration.qll b/xpp/ql/lib/codeql/xpp/elements/LocalDeclaration.qll new file mode 100644 index 000000000000..9aeff1bf4fa7 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/LocalDeclaration.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `LocalDeclaration`. + */ + +private import internal.LocalDeclarationImpl +import codeql.xpp.elements.Declaration + +final class LocalDeclaration = Impl::LocalDeclaration; diff --git a/xpp/ql/lib/codeql/xpp/elements/LocalDeclarationsStatement.qll b/xpp/ql/lib/codeql/xpp/elements/LocalDeclarationsStatement.qll new file mode 100644 index 000000000000..e38864eaecdc --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/LocalDeclarationsStatement.qll @@ -0,0 +1,10 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `LocalDeclarationsStatement`. + */ + +private import internal.LocalDeclarationsStatementImpl +import codeql.xpp.elements.LocalDeclaration +import codeql.xpp.elements.Statement + +final class LocalDeclarationsStatement = Impl::LocalDeclarationsStatement; diff --git a/xpp/ql/lib/codeql/xpp/elements/Locatable.qll b/xpp/ql/lib/codeql/xpp/elements/Locatable.qll new file mode 100644 index 000000000000..d575dbb745fc --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/Locatable.qll @@ -0,0 +1,10 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `Locatable`. + */ + +private import internal.LocatableImpl +import codeql.xpp.elements.Element +import codeql.xpp.elements.Location + +final class Locatable = Impl::Locatable; diff --git a/xpp/ql/lib/codeql/xpp/elements/Location.qll b/xpp/ql/lib/codeql/xpp/elements/Location.qll new file mode 100644 index 000000000000..9acb4f1fa353 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/Location.qll @@ -0,0 +1,10 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `Location`. + */ + +private import internal.LocationImpl +import codeql.xpp.elements.Element +import codeql.xpp.elements.File + +final class Location = Impl::Location; diff --git a/xpp/ql/lib/codeql/xpp/elements/MaxAggregateSelection.qll b/xpp/ql/lib/codeql/xpp/elements/MaxAggregateSelection.qll new file mode 100644 index 000000000000..1c2866568d81 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/MaxAggregateSelection.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `MaxAggregateSelection`. + */ + +private import internal.MaxAggregateSelectionImpl +import codeql.xpp.elements.AggregateSelection + +final class MaxAggregateSelection = Impl::MaxAggregateSelection; diff --git a/xpp/ql/lib/codeql/xpp/elements/Method.qll b/xpp/ql/lib/codeql/xpp/elements/Method.qll new file mode 100644 index 000000000000..f675c72068ca --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/Method.qll @@ -0,0 +1,11 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `Method`. + */ + +private import internal.MethodImpl +import codeql.xpp.elements.LocalDeclaration +import codeql.xpp.elements.MethodOrDelegate +import codeql.xpp.elements.Statement + +final class Method = Impl::Method; diff --git a/xpp/ql/lib/codeql/xpp/elements/MethodOrDelegate.qll b/xpp/ql/lib/codeql/xpp/elements/MethodOrDelegate.qll new file mode 100644 index 000000000000..c6e219df2558 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/MethodOrDelegate.qll @@ -0,0 +1,13 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `MethodOrDelegate`. + */ + +private import internal.MethodOrDelegateImpl +import codeql.xpp.elements.AttributeList +import codeql.xpp.elements.CompilationUnit +import codeql.xpp.elements.Modifier +import codeql.xpp.elements.ParameterDeclaration +import codeql.xpp.elements.XppType + +final class MethodOrDelegate = Impl::MethodOrDelegate; diff --git a/xpp/ql/lib/codeql/xpp/elements/MinAggregateSelection.qll b/xpp/ql/lib/codeql/xpp/elements/MinAggregateSelection.qll new file mode 100644 index 000000000000..561fed0e988a --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/MinAggregateSelection.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `MinAggregateSelection`. + */ + +private import internal.MinAggregateSelectionImpl +import codeql.xpp.elements.AggregateSelection + +final class MinAggregateSelection = Impl::MinAggregateSelection; diff --git a/xpp/ql/lib/codeql/xpp/elements/ModExpression.qll b/xpp/ql/lib/codeql/xpp/elements/ModExpression.qll new file mode 100644 index 000000000000..dfc4c074a19c --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/ModExpression.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `ModExpression`. + */ + +private import internal.ModExpressionImpl +import codeql.xpp.elements.BinaryExpression + +final class ModExpression = Impl::ModExpression; diff --git a/xpp/ql/lib/codeql/xpp/elements/ModelElement.qll b/xpp/ql/lib/codeql/xpp/elements/ModelElement.qll new file mode 100644 index 000000000000..1ba12e1eaec4 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/ModelElement.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `ModelElement`. + */ + +private import internal.ModelElementImpl +import codeql.xpp.elements.ClassAccessModifier +import codeql.xpp.elements.ClassOrInterface +import codeql.xpp.elements.CompilationUnit +import codeql.xpp.elements.MethodOrDelegate +import codeql.xpp.elements.ModelElementUsingEntry +import codeql.xpp.elements.XppType + +final class ModelElement = Impl::ModelElement; diff --git a/xpp/ql/lib/codeql/xpp/elements/ModelElementUsingEntry.qll b/xpp/ql/lib/codeql/xpp/elements/ModelElementUsingEntry.qll new file mode 100644 index 000000000000..538438ded07a --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/ModelElementUsingEntry.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `ModelElementUsingEntry`. + */ + +private import internal.ModelElementUsingEntryImpl +import codeql.xpp.elements.XppTuple + +final class ModelElementUsingEntry = Impl::ModelElementUsingEntry; diff --git a/xpp/ql/lib/codeql/xpp/elements/Modifier.qll b/xpp/ql/lib/codeql/xpp/elements/Modifier.qll new file mode 100644 index 000000000000..abd07c17931b --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/Modifier.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `Modifier`. + */ + +private import internal.ModifierImpl +import codeql.xpp.elements.Ast + +final class Modifier = Impl::Modifier; diff --git a/xpp/ql/lib/codeql/xpp/elements/MoveCursorStatement.qll b/xpp/ql/lib/codeql/xpp/elements/MoveCursorStatement.qll new file mode 100644 index 000000000000..c158ab4be2fa --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/MoveCursorStatement.qll @@ -0,0 +1,10 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `MoveCursorStatement`. + */ + +private import internal.MoveCursorStatementImpl +import codeql.xpp.elements.Selection +import codeql.xpp.elements.Statement + +final class MoveCursorStatement = Impl::MoveCursorStatement; diff --git a/xpp/ql/lib/codeql/xpp/elements/MultiplyExpression.qll b/xpp/ql/lib/codeql/xpp/elements/MultiplyExpression.qll new file mode 100644 index 000000000000..d2fd9af5e2af --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/MultiplyExpression.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `MultiplyExpression`. + */ + +private import internal.MultiplyExpressionImpl +import codeql.xpp.elements.BinaryExpression + +final class MultiplyExpression = Impl::MultiplyExpression; diff --git a/xpp/ql/lib/codeql/xpp/elements/NamedFieldReference.qll b/xpp/ql/lib/codeql/xpp/elements/NamedFieldReference.qll new file mode 100644 index 000000000000..556539b176e5 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/NamedFieldReference.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `NamedFieldReference`. + */ + +private import internal.NamedFieldReferenceImpl +import codeql.xpp.elements.TableFieldReference + +final class NamedFieldReference = Impl::NamedFieldReference; diff --git a/xpp/ql/lib/codeql/xpp/elements/NamedType.qll b/xpp/ql/lib/codeql/xpp/elements/NamedType.qll new file mode 100644 index 000000000000..cd19e8155091 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/NamedType.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `NamedType`. + */ + +private import internal.NamedTypeImpl +import codeql.xpp.elements.GenericXppType + +final class NamedType = Impl::NamedType; diff --git a/xpp/ql/lib/codeql/xpp/elements/NamedTypeInternal.qll b/xpp/ql/lib/codeql/xpp/elements/NamedTypeInternal.qll new file mode 100644 index 000000000000..d3b178e6c3f0 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/NamedTypeInternal.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `NamedTypeInternal`. + */ + +private import internal.NamedTypeInternalImpl +import codeql.xpp.elements.NamedType + +final class NamedTypeInternal = Impl::NamedTypeInternal; diff --git a/xpp/ql/lib/codeql/xpp/elements/NewCall.qll b/xpp/ql/lib/codeql/xpp/elements/NewCall.qll new file mode 100644 index 000000000000..783dfa7afa81 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/NewCall.qll @@ -0,0 +1,10 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `NewCall`. + */ + +private import internal.NewCallImpl +import codeql.xpp.elements.Evaluation +import codeql.xpp.elements.XppType + +final class NewCall = Impl::NewCall; diff --git a/xpp/ql/lib/codeql/xpp/elements/NewClrArrayExpression.qll b/xpp/ql/lib/codeql/xpp/elements/NewClrArrayExpression.qll new file mode 100644 index 000000000000..545f7eb8304b --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/NewClrArrayExpression.qll @@ -0,0 +1,10 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `NewClrArrayExpression`. + */ + +private import internal.NewClrArrayExpressionImpl +import codeql.xpp.elements.Expression +import codeql.xpp.elements.XppType + +final class NewClrArrayExpression = Impl::NewClrArrayExpression; diff --git a/xpp/ql/lib/codeql/xpp/elements/NewClrCall.qll b/xpp/ql/lib/codeql/xpp/elements/NewClrCall.qll new file mode 100644 index 000000000000..e3bb24b5026c --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/NewClrCall.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `NewClrCall`. + */ + +private import internal.NewClrCallImpl +import codeql.xpp.elements.GenericEvaluation + +final class NewClrCall = Impl::NewClrCall; diff --git a/xpp/ql/lib/codeql/xpp/elements/NextExpression.qll b/xpp/ql/lib/codeql/xpp/elements/NextExpression.qll new file mode 100644 index 000000000000..35b1fbb43351 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/NextExpression.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `NextExpression`. + */ + +private import internal.NextExpressionImpl +import codeql.xpp.elements.Evaluation + +final class NextExpression = Impl::NextExpression; diff --git a/xpp/ql/lib/codeql/xpp/elements/NotEqualExpression.qll b/xpp/ql/lib/codeql/xpp/elements/NotEqualExpression.qll new file mode 100644 index 000000000000..97fe5f09dfbd --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/NotEqualExpression.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `NotEqualExpression`. + */ + +private import internal.NotEqualExpressionImpl +import codeql.xpp.elements.RelationalExpression + +final class NotEqualExpression = Impl::NotEqualExpression; diff --git a/xpp/ql/lib/codeql/xpp/elements/NotExpression.qll b/xpp/ql/lib/codeql/xpp/elements/NotExpression.qll new file mode 100644 index 000000000000..887bee147f57 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/NotExpression.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `NotExpression`. + */ + +private import internal.NotExpressionImpl +import codeql.xpp.elements.UnaryExpression + +final class NotExpression = Impl::NotExpression; diff --git a/xpp/ql/lib/codeql/xpp/elements/NullLiteralExpression.qll b/xpp/ql/lib/codeql/xpp/elements/NullLiteralExpression.qll new file mode 100644 index 000000000000..7c73a52ced40 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/NullLiteralExpression.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `NullLiteralExpression`. + */ + +private import internal.NullLiteralExpressionImpl +import codeql.xpp.elements.LiteralExpression + +final class NullLiteralExpression = Impl::NullLiteralExpression; diff --git a/xpp/ql/lib/codeql/xpp/elements/NumberedFieldReference.qll b/xpp/ql/lib/codeql/xpp/elements/NumberedFieldReference.qll new file mode 100644 index 000000000000..927a1e138381 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/NumberedFieldReference.qll @@ -0,0 +1,10 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `NumberedFieldReference`. + */ + +private import internal.NumberedFieldReferenceImpl +import codeql.xpp.elements.Expression +import codeql.xpp.elements.TableFieldReference + +final class NumberedFieldReference = Impl::NumberedFieldReference; diff --git a/xpp/ql/lib/codeql/xpp/elements/OrExpression.qll b/xpp/ql/lib/codeql/xpp/elements/OrExpression.qll new file mode 100644 index 000000000000..980267da9ac6 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/OrExpression.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `OrExpression`. + */ + +private import internal.OrExpressionImpl +import codeql.xpp.elements.BinaryExpression + +final class OrExpression = Impl::OrExpression; diff --git a/xpp/ql/lib/codeql/xpp/elements/OrderElement.qll b/xpp/ql/lib/codeql/xpp/elements/OrderElement.qll new file mode 100644 index 000000000000..5e08afbd02ec --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/OrderElement.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `OrderElement`. + */ + +private import internal.OrderElementImpl +import codeql.xpp.elements.Ast + +final class OrderElement = Impl::OrderElement; diff --git a/xpp/ql/lib/codeql/xpp/elements/ParameterDeclaration.qll b/xpp/ql/lib/codeql/xpp/elements/ParameterDeclaration.qll new file mode 100644 index 000000000000..64f0658a1b19 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/ParameterDeclaration.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `ParameterDeclaration`. + */ + +private import internal.ParameterDeclarationImpl +import codeql.xpp.elements.VariableDeclaration + +final class ParameterDeclaration = Impl::ParameterDeclaration; diff --git a/xpp/ql/lib/codeql/xpp/elements/PhysicalAndExpression.qll b/xpp/ql/lib/codeql/xpp/elements/PhysicalAndExpression.qll new file mode 100644 index 000000000000..53a6e1798862 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/PhysicalAndExpression.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `PhysicalAndExpression`. + */ + +private import internal.PhysicalAndExpressionImpl +import codeql.xpp.elements.BinaryExpression + +final class PhysicalAndExpression = Impl::PhysicalAndExpression; diff --git a/xpp/ql/lib/codeql/xpp/elements/PhysicalNotExpression.qll b/xpp/ql/lib/codeql/xpp/elements/PhysicalNotExpression.qll new file mode 100644 index 000000000000..9e82fef0d4f1 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/PhysicalNotExpression.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `PhysicalNotExpression`. + */ + +private import internal.PhysicalNotExpressionImpl +import codeql.xpp.elements.UnaryExpression + +final class PhysicalNotExpression = Impl::PhysicalNotExpression; diff --git a/xpp/ql/lib/codeql/xpp/elements/PhysicalOrExpression.qll b/xpp/ql/lib/codeql/xpp/elements/PhysicalOrExpression.qll new file mode 100644 index 000000000000..c1b63e0e24c8 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/PhysicalOrExpression.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `PhysicalOrExpression`. + */ + +private import internal.PhysicalOrExpressionImpl +import codeql.xpp.elements.BinaryExpression + +final class PhysicalOrExpression = Impl::PhysicalOrExpression; diff --git a/xpp/ql/lib/codeql/xpp/elements/PhysicalXorExpression.qll b/xpp/ql/lib/codeql/xpp/elements/PhysicalXorExpression.qll new file mode 100644 index 000000000000..ff26d145eb76 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/PhysicalXorExpression.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `PhysicalXorExpression`. + */ + +private import internal.PhysicalXorExpressionImpl +import codeql.xpp.elements.BinaryExpression + +final class PhysicalXorExpression = Impl::PhysicalXorExpression; diff --git a/xpp/ql/lib/codeql/xpp/elements/Placeholder.qll b/xpp/ql/lib/codeql/xpp/elements/Placeholder.qll new file mode 100644 index 000000000000..48109beeb2bc --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/Placeholder.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `Placeholder`. + */ + +private import internal.PlaceholderImpl +import codeql.xpp.elements.Expression + +final class Placeholder = Impl::Placeholder; diff --git a/xpp/ql/lib/codeql/xpp/elements/PrintStatement.qll b/xpp/ql/lib/codeql/xpp/elements/PrintStatement.qll new file mode 100644 index 000000000000..24b310fdc92f --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/PrintStatement.qll @@ -0,0 +1,10 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `PrintStatement`. + */ + +private import internal.PrintStatementImpl +import codeql.xpp.elements.Expression +import codeql.xpp.elements.Statement + +final class PrintStatement = Impl::PrintStatement; diff --git a/xpp/ql/lib/codeql/xpp/elements/ProvidedType.qll b/xpp/ql/lib/codeql/xpp/elements/ProvidedType.qll new file mode 100644 index 000000000000..02ec433a44d7 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/ProvidedType.qll @@ -0,0 +1,10 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `ProvidedType`. + */ + +private import internal.ProvidedTypeImpl +import codeql.xpp.elements.Expression +import codeql.xpp.elements.XppType + +final class ProvidedType = Impl::ProvidedType; diff --git a/xpp/ql/lib/codeql/xpp/elements/ProvidedTypeStaticCall.qll b/xpp/ql/lib/codeql/xpp/elements/ProvidedTypeStaticCall.qll new file mode 100644 index 000000000000..7c3eff1fa2e5 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/ProvidedTypeStaticCall.qll @@ -0,0 +1,10 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `ProvidedTypeStaticCall`. + */ + +private import internal.ProvidedTypeStaticCallImpl +import codeql.xpp.elements.Evaluation +import codeql.xpp.elements.ProvidedType + +final class ProvidedTypeStaticCall = Impl::ProvidedTypeStaticCall; diff --git a/xpp/ql/lib/codeql/xpp/elements/QualifiedCall.qll b/xpp/ql/lib/codeql/xpp/elements/QualifiedCall.qll new file mode 100644 index 000000000000..ae2fc66b8d32 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/QualifiedCall.qll @@ -0,0 +1,10 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `QualifiedCall`. + */ + +private import internal.QualifiedCallImpl +import codeql.xpp.elements.GenericEvaluation +import codeql.xpp.elements.Qualifier + +final class QualifiedCall = Impl::QualifiedCall; diff --git a/xpp/ql/lib/codeql/xpp/elements/QualifiedField.qll b/xpp/ql/lib/codeql/xpp/elements/QualifiedField.qll new file mode 100644 index 000000000000..5ea1f9e8b160 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/QualifiedField.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `QualifiedField`. + */ + +private import internal.QualifiedFieldImpl +import codeql.xpp.elements.FieldSpecification + +final class QualifiedField = Impl::QualifiedField; diff --git a/xpp/ql/lib/codeql/xpp/elements/QualifiedInstanceName.qll b/xpp/ql/lib/codeql/xpp/elements/QualifiedInstanceName.qll new file mode 100644 index 000000000000..99821b839a29 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/QualifiedInstanceName.qll @@ -0,0 +1,11 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `QualifiedInstanceName`. + */ + +private import internal.QualifiedInstanceNameImpl +import codeql.xpp.elements.Expression +import codeql.xpp.elements.InstanceName +import codeql.xpp.elements.Qualifier + +final class QualifiedInstanceName = Impl::QualifiedInstanceName; diff --git a/xpp/ql/lib/codeql/xpp/elements/QualifiedNumberedField.qll b/xpp/ql/lib/codeql/xpp/elements/QualifiedNumberedField.qll new file mode 100644 index 000000000000..767ca6c479b8 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/QualifiedNumberedField.qll @@ -0,0 +1,10 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `QualifiedNumberedField`. + */ + +private import internal.QualifiedNumberedFieldImpl +import codeql.xpp.elements.Expression +import codeql.xpp.elements.FieldSpecification + +final class QualifiedNumberedField = Impl::QualifiedNumberedField; diff --git a/xpp/ql/lib/codeql/xpp/elements/QualifiedStaticCall.qll b/xpp/ql/lib/codeql/xpp/elements/QualifiedStaticCall.qll new file mode 100644 index 000000000000..c7a985b46217 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/QualifiedStaticCall.qll @@ -0,0 +1,11 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `QualifiedStaticCall`. + */ + +private import internal.QualifiedStaticCallImpl +import codeql.xpp.elements.GenericEvaluation +import codeql.xpp.elements.Qualifier +import codeql.xpp.elements.XppType + +final class QualifiedStaticCall = Impl::QualifiedStaticCall; diff --git a/xpp/ql/lib/codeql/xpp/elements/QualifiedStaticField.qll b/xpp/ql/lib/codeql/xpp/elements/QualifiedStaticField.qll new file mode 100644 index 000000000000..ffa4df8258be --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/QualifiedStaticField.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `QualifiedStaticField`. + */ + +private import internal.QualifiedStaticFieldImpl +import codeql.xpp.elements.FieldSpecification + +final class QualifiedStaticField = Impl::QualifiedStaticField; diff --git a/xpp/ql/lib/codeql/xpp/elements/QualifiedStaticFieldExpression.qll b/xpp/ql/lib/codeql/xpp/elements/QualifiedStaticFieldExpression.qll new file mode 100644 index 000000000000..cc57c7f7c16a --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/QualifiedStaticFieldExpression.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `QualifiedStaticFieldExpression`. + */ + +private import internal.QualifiedStaticFieldExpressionImpl +import codeql.xpp.elements.FieldExpression + +final class QualifiedStaticFieldExpression = Impl::QualifiedStaticFieldExpression; diff --git a/xpp/ql/lib/codeql/xpp/elements/Qualifier.qll b/xpp/ql/lib/codeql/xpp/elements/Qualifier.qll new file mode 100644 index 000000000000..1395c6f4a6bc --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/Qualifier.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `Qualifier`. + */ + +private import internal.QualifierImpl +import codeql.xpp.elements.Ast + +final class Qualifier = Impl::Qualifier; diff --git a/xpp/ql/lib/codeql/xpp/elements/Query.qll b/xpp/ql/lib/codeql/xpp/elements/Query.qll new file mode 100644 index 000000000000..1c74f3ef8ef2 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/Query.qll @@ -0,0 +1,15 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `Query`. + */ + +private import internal.QueryImpl +import codeql.xpp.elements.Ast +import codeql.xpp.elements.CrossCompany +import codeql.xpp.elements.Expression +import codeql.xpp.elements.JoinSpecification +import codeql.xpp.elements.OrderElement +import codeql.xpp.elements.Selection +import codeql.xpp.elements.ValidTimeState + +final class Query = Impl::Query; diff --git a/xpp/ql/lib/codeql/xpp/elements/QueryDataSource.qll b/xpp/ql/lib/codeql/xpp/elements/QueryDataSource.qll new file mode 100644 index 000000000000..925c5cc0af87 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/QueryDataSource.qll @@ -0,0 +1,13 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `QueryDataSource`. + */ + +private import internal.QueryDataSourceImpl +import codeql.xpp.elements.Ast +import codeql.xpp.elements.GlobalOrderElement +import codeql.xpp.elements.QueryDataSourceHaving +import codeql.xpp.elements.QueryDataSourceRange +import codeql.xpp.elements.QueryDataSourceRelation + +final class QueryDataSource = Impl::QueryDataSource; diff --git a/xpp/ql/lib/codeql/xpp/elements/QueryDataSourceHaving.qll b/xpp/ql/lib/codeql/xpp/elements/QueryDataSourceHaving.qll new file mode 100644 index 000000000000..5b812d8e5364 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/QueryDataSourceHaving.qll @@ -0,0 +1,10 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `QueryDataSourceHaving`. + */ + +private import internal.QueryDataSourceHavingImpl +import codeql.xpp.elements.Ast +import codeql.xpp.elements.SelectionField + +final class QueryDataSourceHaving = Impl::QueryDataSourceHaving; diff --git a/xpp/ql/lib/codeql/xpp/elements/QueryDataSourceRange.qll b/xpp/ql/lib/codeql/xpp/elements/QueryDataSourceRange.qll new file mode 100644 index 000000000000..4574b8f2718b --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/QueryDataSourceRange.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `QueryDataSourceRange`. + */ + +private import internal.QueryDataSourceRangeImpl +import codeql.xpp.elements.Ast + +final class QueryDataSourceRange = Impl::QueryDataSourceRange; diff --git a/xpp/ql/lib/codeql/xpp/elements/QueryDataSourceRelation.qll b/xpp/ql/lib/codeql/xpp/elements/QueryDataSourceRelation.qll new file mode 100644 index 000000000000..dd7960f3ca35 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/QueryDataSourceRelation.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `QueryDataSourceRelation`. + */ + +private import internal.QueryDataSourceRelationImpl +import codeql.xpp.elements.Ast + +final class QueryDataSourceRelation = Impl::QueryDataSourceRelation; diff --git a/xpp/ql/lib/codeql/xpp/elements/QueryModelElement.qll b/xpp/ql/lib/codeql/xpp/elements/QueryModelElement.qll new file mode 100644 index 000000000000..7cf1f0e2abe7 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/QueryModelElement.qll @@ -0,0 +1,11 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `QueryModelElement`. + */ + +private import internal.QueryModelElementImpl +import codeql.xpp.elements.Class +import codeql.xpp.elements.ModelElement +import codeql.xpp.elements.QueryDataSource + +final class QueryModelElement = Impl::QueryModelElement; diff --git a/xpp/ql/lib/codeql/xpp/elements/RealLiteralExpression.qll b/xpp/ql/lib/codeql/xpp/elements/RealLiteralExpression.qll new file mode 100644 index 000000000000..01019c49776b --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/RealLiteralExpression.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `RealLiteralExpression`. + */ + +private import internal.RealLiteralExpressionImpl +import codeql.xpp.elements.DefaultTypeLiteralExpression + +final class RealLiteralExpression = Impl::RealLiteralExpression; diff --git a/xpp/ql/lib/codeql/xpp/elements/RelationalExpression.qll b/xpp/ql/lib/codeql/xpp/elements/RelationalExpression.qll new file mode 100644 index 000000000000..b365993b633e --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/RelationalExpression.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `RelationalExpression`. + */ + +private import internal.RelationalExpressionImpl +import codeql.xpp.elements.BinaryExpression + +final class RelationalExpression = Impl::RelationalExpression; diff --git a/xpp/ql/lib/codeql/xpp/elements/RetryStatement.qll b/xpp/ql/lib/codeql/xpp/elements/RetryStatement.qll new file mode 100644 index 000000000000..1611c1ad5e72 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/RetryStatement.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `RetryStatement`. + */ + +private import internal.RetryStatementImpl +import codeql.xpp.elements.Statement + +final class RetryStatement = Impl::RetryStatement; diff --git a/xpp/ql/lib/codeql/xpp/elements/ReturnStatement.qll b/xpp/ql/lib/codeql/xpp/elements/ReturnStatement.qll new file mode 100644 index 000000000000..6c7580fd91ad --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/ReturnStatement.qll @@ -0,0 +1,10 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `ReturnStatement`. + */ + +private import internal.ReturnStatementImpl +import codeql.xpp.elements.Expression +import codeql.xpp.elements.Statement + +final class ReturnStatement = Impl::ReturnStatement; diff --git a/xpp/ql/lib/codeql/xpp/elements/SearchStatement.qll b/xpp/ql/lib/codeql/xpp/elements/SearchStatement.qll new file mode 100644 index 000000000000..28f91f610902 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/SearchStatement.qll @@ -0,0 +1,10 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `SearchStatement`. + */ + +private import internal.SearchStatementImpl +import codeql.xpp.elements.Query +import codeql.xpp.elements.Statement + +final class SearchStatement = Impl::SearchStatement; diff --git a/xpp/ql/lib/codeql/xpp/elements/Selection.qll b/xpp/ql/lib/codeql/xpp/elements/Selection.qll new file mode 100644 index 000000000000..7f4fc047d8ef --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/Selection.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `Selection`. + */ + +private import internal.SelectionImpl +import codeql.xpp.elements.Ast + +final class Selection = Impl::Selection; diff --git a/xpp/ql/lib/codeql/xpp/elements/SelectionField.qll b/xpp/ql/lib/codeql/xpp/elements/SelectionField.qll new file mode 100644 index 000000000000..c7d273de037c --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/SelectionField.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `SelectionField`. + */ + +private import internal.SelectionFieldImpl +import codeql.xpp.elements.Ast + +final class SelectionField = Impl::SelectionField; diff --git a/xpp/ql/lib/codeql/xpp/elements/ShiftLeftExpression.qll b/xpp/ql/lib/codeql/xpp/elements/ShiftLeftExpression.qll new file mode 100644 index 000000000000..15392e077ed7 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/ShiftLeftExpression.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `ShiftLeftExpression`. + */ + +private import internal.ShiftLeftExpressionImpl +import codeql.xpp.elements.BinaryExpression + +final class ShiftLeftExpression = Impl::ShiftLeftExpression; diff --git a/xpp/ql/lib/codeql/xpp/elements/ShiftRightExpression.qll b/xpp/ql/lib/codeql/xpp/elements/ShiftRightExpression.qll new file mode 100644 index 000000000000..2d91dea3c57f --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/ShiftRightExpression.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `ShiftRightExpression`. + */ + +private import internal.ShiftRightExpressionImpl +import codeql.xpp.elements.BinaryExpression + +final class ShiftRightExpression = Impl::ShiftRightExpression; diff --git a/xpp/ql/lib/codeql/xpp/elements/SimpleField.qll b/xpp/ql/lib/codeql/xpp/elements/SimpleField.qll new file mode 100644 index 000000000000..0c9f2bb84532 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/SimpleField.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `SimpleField`. + */ + +private import internal.SimpleFieldImpl +import codeql.xpp.elements.FieldSpecification + +final class SimpleField = Impl::SimpleField; diff --git a/xpp/ql/lib/codeql/xpp/elements/SimpleInstanceName.qll b/xpp/ql/lib/codeql/xpp/elements/SimpleInstanceName.qll new file mode 100644 index 000000000000..715969d6056b --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/SimpleInstanceName.qll @@ -0,0 +1,10 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `SimpleInstanceName`. + */ + +private import internal.SimpleInstanceNameImpl +import codeql.xpp.elements.Expression +import codeql.xpp.elements.InstanceName + +final class SimpleInstanceName = Impl::SimpleInstanceName; diff --git a/xpp/ql/lib/codeql/xpp/elements/SimpleOrderElement.qll b/xpp/ql/lib/codeql/xpp/elements/SimpleOrderElement.qll new file mode 100644 index 000000000000..72bad445eca3 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/SimpleOrderElement.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `SimpleOrderElement`. + */ + +private import internal.SimpleOrderElementImpl +import codeql.xpp.elements.OrderElement + +final class SimpleOrderElement = Impl::SimpleOrderElement; diff --git a/xpp/ql/lib/codeql/xpp/elements/SimpleQualifier.qll b/xpp/ql/lib/codeql/xpp/elements/SimpleQualifier.qll new file mode 100644 index 000000000000..f245fa4e1f27 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/SimpleQualifier.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `SimpleQualifier`. + */ + +private import internal.SimpleQualifierImpl +import codeql.xpp.elements.Qualifier + +final class SimpleQualifier = Impl::SimpleQualifier; diff --git a/xpp/ql/lib/codeql/xpp/elements/SimpleQualifierInternal.qll b/xpp/ql/lib/codeql/xpp/elements/SimpleQualifierInternal.qll new file mode 100644 index 000000000000..d2d89f5c1d71 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/SimpleQualifierInternal.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `SimpleQualifierInternal`. + */ + +private import internal.SimpleQualifierInternalImpl +import codeql.xpp.elements.SimpleQualifier + +final class SimpleQualifierInternal = Impl::SimpleQualifierInternal; diff --git a/xpp/ql/lib/codeql/xpp/elements/Statement.qll b/xpp/ql/lib/codeql/xpp/elements/Statement.qll new file mode 100644 index 000000000000..71c84551b5d1 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/Statement.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `Statement`. + */ + +private import internal.StatementImpl +import codeql.xpp.elements.Ast + +final class Statement = Impl::Statement; diff --git a/xpp/ql/lib/codeql/xpp/elements/StaticField.qll b/xpp/ql/lib/codeql/xpp/elements/StaticField.qll new file mode 100644 index 000000000000..b15ec12b985b --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/StaticField.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `StaticField`. + */ + +private import internal.StaticFieldImpl +import codeql.xpp.elements.FieldSpecification + +final class StaticField = Impl::StaticField; diff --git a/xpp/ql/lib/codeql/xpp/elements/StaticMethodCall.qll b/xpp/ql/lib/codeql/xpp/elements/StaticMethodCall.qll new file mode 100644 index 000000000000..cb62e143574b --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/StaticMethodCall.qll @@ -0,0 +1,10 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `StaticMethodCall`. + */ + +private import internal.StaticMethodCallImpl +import codeql.xpp.elements.GenericEvaluation +import codeql.xpp.elements.XppType + +final class StaticMethodCall = Impl::StaticMethodCall; diff --git a/xpp/ql/lib/codeql/xpp/elements/StaticQualifier.qll b/xpp/ql/lib/codeql/xpp/elements/StaticQualifier.qll new file mode 100644 index 000000000000..789bb66c073e --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/StaticQualifier.qll @@ -0,0 +1,10 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `StaticQualifier`. + */ + +private import internal.StaticQualifierImpl +import codeql.xpp.elements.SimpleQualifier +import codeql.xpp.elements.XppType + +final class StaticQualifier = Impl::StaticQualifier; diff --git a/xpp/ql/lib/codeql/xpp/elements/StringAttributeLiteral.qll b/xpp/ql/lib/codeql/xpp/elements/StringAttributeLiteral.qll new file mode 100644 index 000000000000..3ebce0e2c4bf --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/StringAttributeLiteral.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `StringAttributeLiteral`. + */ + +private import internal.StringAttributeLiteralImpl +import codeql.xpp.elements.DefaultTypeAttributeLiteral + +final class StringAttributeLiteral = Impl::StringAttributeLiteral; diff --git a/xpp/ql/lib/codeql/xpp/elements/StringLengthType.qll b/xpp/ql/lib/codeql/xpp/elements/StringLengthType.qll new file mode 100644 index 000000000000..3cf76df55f35 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/StringLengthType.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `StringLengthType`. + */ + +private import internal.StringLengthTypeImpl +import codeql.xpp.elements.StringType + +final class StringLengthType = Impl::StringLengthType; diff --git a/xpp/ql/lib/codeql/xpp/elements/StringLiteralExpression.qll b/xpp/ql/lib/codeql/xpp/elements/StringLiteralExpression.qll new file mode 100644 index 000000000000..c561b1fafb50 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/StringLiteralExpression.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `StringLiteralExpression`. + */ + +private import internal.StringLiteralExpressionImpl +import codeql.xpp.elements.DefaultTypeLiteralExpression + +final class StringLiteralExpression = Impl::StringLiteralExpression; diff --git a/xpp/ql/lib/codeql/xpp/elements/StringType.qll b/xpp/ql/lib/codeql/xpp/elements/StringType.qll new file mode 100644 index 000000000000..620af7b91460 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/StringType.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `StringType`. + */ + +private import internal.StringTypeImpl +import codeql.xpp.elements.XppType + +final class StringType = Impl::StringType; diff --git a/xpp/ql/lib/codeql/xpp/elements/StringTypeInternal.qll b/xpp/ql/lib/codeql/xpp/elements/StringTypeInternal.qll new file mode 100644 index 000000000000..6e17f43bf7de --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/StringTypeInternal.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `StringTypeInternal`. + */ + +private import internal.StringTypeInternalImpl +import codeql.xpp.elements.StringType + +final class StringTypeInternal = Impl::StringTypeInternal; diff --git a/xpp/ql/lib/codeql/xpp/elements/SubtractExpression.qll b/xpp/ql/lib/codeql/xpp/elements/SubtractExpression.qll new file mode 100644 index 000000000000..eea6890c0c08 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/SubtractExpression.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `SubtractExpression`. + */ + +private import internal.SubtractExpressionImpl +import codeql.xpp.elements.BinaryExpression + +final class SubtractExpression = Impl::SubtractExpression; diff --git a/xpp/ql/lib/codeql/xpp/elements/SumAggregateSelection.qll b/xpp/ql/lib/codeql/xpp/elements/SumAggregateSelection.qll new file mode 100644 index 000000000000..419855ccb7f7 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/SumAggregateSelection.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `SumAggregateSelection`. + */ + +private import internal.SumAggregateSelectionImpl +import codeql.xpp.elements.AggregateSelection + +final class SumAggregateSelection = Impl::SumAggregateSelection; diff --git a/xpp/ql/lib/codeql/xpp/elements/SuperCall.qll b/xpp/ql/lib/codeql/xpp/elements/SuperCall.qll new file mode 100644 index 000000000000..610a5c4889ce --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/SuperCall.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `SuperCall`. + */ + +private import internal.SuperCallImpl +import codeql.xpp.elements.Evaluation + +final class SuperCall = Impl::SuperCall; diff --git a/xpp/ql/lib/codeql/xpp/elements/SwitchCase.qll b/xpp/ql/lib/codeql/xpp/elements/SwitchCase.qll new file mode 100644 index 000000000000..ecc49b02d0de --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/SwitchCase.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `SwitchCase`. + */ + +private import internal.SwitchCaseImpl +import codeql.xpp.elements.Ast + +final class SwitchCase = Impl::SwitchCase; diff --git a/xpp/ql/lib/codeql/xpp/elements/SwitchStatement.qll b/xpp/ql/lib/codeql/xpp/elements/SwitchStatement.qll new file mode 100644 index 000000000000..7fefe4049a69 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/SwitchStatement.qll @@ -0,0 +1,11 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `SwitchStatement`. + */ + +private import internal.SwitchStatementImpl +import codeql.xpp.elements.Expression +import codeql.xpp.elements.Statement +import codeql.xpp.elements.SwitchStatementCaseEntry + +final class SwitchStatement = Impl::SwitchStatement; diff --git a/xpp/ql/lib/codeql/xpp/elements/SwitchStatementCaseEntry.qll b/xpp/ql/lib/codeql/xpp/elements/SwitchStatementCaseEntry.qll new file mode 100644 index 000000000000..aed5c3986e62 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/SwitchStatementCaseEntry.qll @@ -0,0 +1,11 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `SwitchStatementCaseEntry`. + */ + +private import internal.SwitchStatementCaseEntryImpl +import codeql.xpp.elements.Case +import codeql.xpp.elements.Statement +import codeql.xpp.elements.XppTuple + +final class SwitchStatementCaseEntry = Impl::SwitchStatementCaseEntry; diff --git a/xpp/ql/lib/codeql/xpp/elements/Table.qll b/xpp/ql/lib/codeql/xpp/elements/Table.qll new file mode 100644 index 000000000000..740481f3cce8 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/Table.qll @@ -0,0 +1,11 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `Table`. + */ + +private import internal.TableImpl +import codeql.xpp.elements.AttributeList +import codeql.xpp.elements.FieldDeclaration +import codeql.xpp.elements.ModelElement + +final class Table = Impl::Table; diff --git a/xpp/ql/lib/codeql/xpp/elements/TableFieldDeclaration.qll b/xpp/ql/lib/codeql/xpp/elements/TableFieldDeclaration.qll new file mode 100644 index 000000000000..262e60478de0 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/TableFieldDeclaration.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `TableFieldDeclaration`. + */ + +private import internal.TableFieldDeclarationImpl +import codeql.xpp.elements.FieldDeclaration + +final class TableFieldDeclaration = Impl::TableFieldDeclaration; diff --git a/xpp/ql/lib/codeql/xpp/elements/TableFieldReference.qll b/xpp/ql/lib/codeql/xpp/elements/TableFieldReference.qll new file mode 100644 index 000000000000..e1c51ecf89fb --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/TableFieldReference.qll @@ -0,0 +1,10 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `TableFieldReference`. + */ + +private import internal.TableFieldReferenceImpl +import codeql.xpp.elements.Ast +import codeql.xpp.elements.Expression + +final class TableFieldReference = Impl::TableFieldReference; diff --git a/xpp/ql/lib/codeql/xpp/elements/TableLookupExpression.qll b/xpp/ql/lib/codeql/xpp/elements/TableLookupExpression.qll new file mode 100644 index 000000000000..0e41d2d796fe --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/TableLookupExpression.qll @@ -0,0 +1,11 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `TableLookupExpression`. + */ + +private import internal.TableLookupExpressionImpl +import codeql.xpp.elements.Expression +import codeql.xpp.elements.Query +import codeql.xpp.elements.TableFieldReference + +final class TableLookupExpression = Impl::TableLookupExpression; diff --git a/xpp/ql/lib/codeql/xpp/elements/ThrowStatement.qll b/xpp/ql/lib/codeql/xpp/elements/ThrowStatement.qll new file mode 100644 index 000000000000..c7bd3c247abd --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/ThrowStatement.qll @@ -0,0 +1,10 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `ThrowStatement`. + */ + +private import internal.ThrowStatementImpl +import codeql.xpp.elements.Expression +import codeql.xpp.elements.Statement + +final class ThrowStatement = Impl::ThrowStatement; diff --git a/xpp/ql/lib/codeql/xpp/elements/TryStatement.qll b/xpp/ql/lib/codeql/xpp/elements/TryStatement.qll new file mode 100644 index 000000000000..12526144edae --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/TryStatement.qll @@ -0,0 +1,10 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `TryStatement`. + */ + +private import internal.TryStatementImpl +import codeql.xpp.elements.Statement +import codeql.xpp.elements.TryStatementCatchEntry + +final class TryStatement = Impl::TryStatement; diff --git a/xpp/ql/lib/codeql/xpp/elements/TryStatementCatchEntry.qll b/xpp/ql/lib/codeql/xpp/elements/TryStatementCatchEntry.qll new file mode 100644 index 000000000000..dfe8049dd8c1 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/TryStatementCatchEntry.qll @@ -0,0 +1,11 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `TryStatementCatchEntry`. + */ + +private import internal.TryStatementCatchEntryImpl +import codeql.xpp.elements.Catch +import codeql.xpp.elements.Statement +import codeql.xpp.elements.XppTuple + +final class TryStatementCatchEntry = Impl::TryStatementCatchEntry; diff --git a/xpp/ql/lib/codeql/xpp/elements/TtsAbortStatement.qll b/xpp/ql/lib/codeql/xpp/elements/TtsAbortStatement.qll new file mode 100644 index 000000000000..81d7f9a0cfd4 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/TtsAbortStatement.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `TtsAbortStatement`. + */ + +private import internal.TtsAbortStatementImpl +import codeql.xpp.elements.TtsStatement + +final class TtsAbortStatement = Impl::TtsAbortStatement; diff --git a/xpp/ql/lib/codeql/xpp/elements/TtsBeginStatement.qll b/xpp/ql/lib/codeql/xpp/elements/TtsBeginStatement.qll new file mode 100644 index 000000000000..2931ae225bb9 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/TtsBeginStatement.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `TtsBeginStatement`. + */ + +private import internal.TtsBeginStatementImpl +import codeql.xpp.elements.TtsStatement + +final class TtsBeginStatement = Impl::TtsBeginStatement; diff --git a/xpp/ql/lib/codeql/xpp/elements/TtsEndStatement.qll b/xpp/ql/lib/codeql/xpp/elements/TtsEndStatement.qll new file mode 100644 index 000000000000..302f5f931a3f --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/TtsEndStatement.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `TtsEndStatement`. + */ + +private import internal.TtsEndStatementImpl +import codeql.xpp.elements.TtsStatement + +final class TtsEndStatement = Impl::TtsEndStatement; diff --git a/xpp/ql/lib/codeql/xpp/elements/TtsStatement.qll b/xpp/ql/lib/codeql/xpp/elements/TtsStatement.qll new file mode 100644 index 000000000000..8a524e87db7c --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/TtsStatement.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `TtsStatement`. + */ + +private import internal.TtsStatementImpl +import codeql.xpp.elements.Statement + +final class TtsStatement = Impl::TtsStatement; diff --git a/xpp/ql/lib/codeql/xpp/elements/UnaryExpression.qll b/xpp/ql/lib/codeql/xpp/elements/UnaryExpression.qll new file mode 100644 index 000000000000..08199e9d1f1e --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/UnaryExpression.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `UnaryExpression`. + */ + +private import internal.UnaryExpressionImpl +import codeql.xpp.elements.Expression + +final class UnaryExpression = Impl::UnaryExpression; diff --git a/xpp/ql/lib/codeql/xpp/elements/UnaryMinusExpression.qll b/xpp/ql/lib/codeql/xpp/elements/UnaryMinusExpression.qll new file mode 100644 index 000000000000..9ce18a2f3b7f --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/UnaryMinusExpression.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `UnaryMinusExpression`. + */ + +private import internal.UnaryMinusExpressionImpl +import codeql.xpp.elements.UnaryExpression + +final class UnaryMinusExpression = Impl::UnaryMinusExpression; diff --git a/xpp/ql/lib/codeql/xpp/elements/UncheckedStatement.qll b/xpp/ql/lib/codeql/xpp/elements/UncheckedStatement.qll new file mode 100644 index 000000000000..4abaf478cb94 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/UncheckedStatement.qll @@ -0,0 +1,10 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `UncheckedStatement`. + */ + +private import internal.UncheckedStatementImpl +import codeql.xpp.elements.Expression +import codeql.xpp.elements.Statement + +final class UncheckedStatement = Impl::UncheckedStatement; diff --git a/xpp/ql/lib/codeql/xpp/elements/UnspecifiedElement.qll b/xpp/ql/lib/codeql/xpp/elements/UnspecifiedElement.qll new file mode 100644 index 000000000000..6aeeb7040d5d --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/UnspecifiedElement.qll @@ -0,0 +1,13 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `UnspecifiedElement`. + */ + +private import internal.UnspecifiedElementImpl +import codeql.xpp.elements.Element +import codeql.xpp.elements.ErrorElement + +/** + * A node that could not be extracted, for example because of a syntax error. + */ +final class UnspecifiedElement = Impl::UnspecifiedElement; diff --git a/xpp/ql/lib/codeql/xpp/elements/UpdateStatement.qll b/xpp/ql/lib/codeql/xpp/elements/UpdateStatement.qll new file mode 100644 index 000000000000..51417643c279 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/UpdateStatement.qll @@ -0,0 +1,13 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `UpdateStatement`. + */ + +private import internal.UpdateStatementImpl +import codeql.xpp.elements.CrossCompany +import codeql.xpp.elements.Expression +import codeql.xpp.elements.FieldAssignment +import codeql.xpp.elements.JoinSpecification +import codeql.xpp.elements.Statement + +final class UpdateStatement = Impl::UpdateStatement; diff --git a/xpp/ql/lib/codeql/xpp/elements/UsingStatement.qll b/xpp/ql/lib/codeql/xpp/elements/UsingStatement.qll new file mode 100644 index 000000000000..7d81b2c49b0d --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/UsingStatement.qll @@ -0,0 +1,10 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `UsingStatement`. + */ + +private import internal.UsingStatementImpl +import codeql.xpp.elements.Statement +import codeql.xpp.elements.VariableDeclaration + +final class UsingStatement = Impl::UsingStatement; diff --git a/xpp/ql/lib/codeql/xpp/elements/ValidTimeState.qll b/xpp/ql/lib/codeql/xpp/elements/ValidTimeState.qll new file mode 100644 index 000000000000..c5e838e9a26b --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/ValidTimeState.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `ValidTimeState`. + */ + +private import internal.ValidTimeStateImpl +import codeql.xpp.elements.Ast + +final class ValidTimeState = Impl::ValidTimeState; diff --git a/xpp/ql/lib/codeql/xpp/elements/ValidTimeStateDate.qll b/xpp/ql/lib/codeql/xpp/elements/ValidTimeStateDate.qll new file mode 100644 index 000000000000..7c885356725e --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/ValidTimeStateDate.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `ValidTimeStateDate`. + */ + +private import internal.ValidTimeStateDateImpl +import codeql.xpp.elements.ValidTimeState + +final class ValidTimeStateDate = Impl::ValidTimeStateDate; diff --git a/xpp/ql/lib/codeql/xpp/elements/ValidTimeStateRange.qll b/xpp/ql/lib/codeql/xpp/elements/ValidTimeStateRange.qll new file mode 100644 index 000000000000..345820870989 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/ValidTimeStateRange.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `ValidTimeStateRange`. + */ + +private import internal.ValidTimeStateRangeImpl +import codeql.xpp.elements.ValidTimeState + +final class ValidTimeStateRange = Impl::ValidTimeStateRange; diff --git a/xpp/ql/lib/codeql/xpp/elements/VarType.qll b/xpp/ql/lib/codeql/xpp/elements/VarType.qll new file mode 100644 index 000000000000..70ed9f24e95a --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/VarType.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `VarType`. + */ + +private import internal.VarTypeImpl +import codeql.xpp.elements.XppType + +final class VarType = Impl::VarType; diff --git a/xpp/ql/lib/codeql/xpp/elements/VariableDeclaration.qll b/xpp/ql/lib/codeql/xpp/elements/VariableDeclaration.qll new file mode 100644 index 000000000000..ff220915ebd7 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/VariableDeclaration.qll @@ -0,0 +1,10 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `VariableDeclaration`. + */ + +private import internal.VariableDeclarationImpl +import codeql.xpp.elements.Expression +import codeql.xpp.elements.LocalDeclaration + +final class VariableDeclaration = Impl::VariableDeclaration; diff --git a/xpp/ql/lib/codeql/xpp/elements/VariableDeclarationInternal.qll b/xpp/ql/lib/codeql/xpp/elements/VariableDeclarationInternal.qll new file mode 100644 index 000000000000..e7a3d8a4f40b --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/VariableDeclarationInternal.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `VariableDeclarationInternal`. + */ + +private import internal.VariableDeclarationInternalImpl +import codeql.xpp.elements.VariableDeclaration + +final class VariableDeclarationInternal = Impl::VariableDeclarationInternal; diff --git a/xpp/ql/lib/codeql/xpp/elements/VoidType.qll b/xpp/ql/lib/codeql/xpp/elements/VoidType.qll new file mode 100644 index 000000000000..f7e3c1f77042 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/VoidType.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `VoidType`. + */ + +private import internal.VoidTypeImpl +import codeql.xpp.elements.XppType + +final class VoidType = Impl::VoidType; diff --git a/xpp/ql/lib/codeql/xpp/elements/WhileStatement.qll b/xpp/ql/lib/codeql/xpp/elements/WhileStatement.qll new file mode 100644 index 000000000000..a0eb36617e62 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/WhileStatement.qll @@ -0,0 +1,10 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `WhileStatement`. + */ + +private import internal.WhileStatementImpl +import codeql.xpp.elements.Expression +import codeql.xpp.elements.Statement + +final class WhileStatement = Impl::WhileStatement; diff --git a/xpp/ql/lib/codeql/xpp/elements/XppTuple.qll b/xpp/ql/lib/codeql/xpp/elements/XppTuple.qll new file mode 100644 index 000000000000..804157d1085c --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/XppTuple.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `XppTuple`. + */ + +private import internal.XppTupleImpl +import codeql.xpp.elements.Locatable + +/** + * Base of the classes standing in for tuples in the compiler's AST. + * + * The X++ compiler uses CLR tuples for a handful of grouped values, such as a `catch` + * together with its handler body. The schema has no tuple type, so the generator emits a + * named class per tuple-valued property instead. + */ +final class XppTuple = Impl::XppTuple; diff --git a/xpp/ql/lib/codeql/xpp/elements/XppType.qll b/xpp/ql/lib/codeql/xpp/elements/XppType.qll new file mode 100644 index 000000000000..d00e6e691caa --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/XppType.qll @@ -0,0 +1,9 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `XppType`. + */ + +private import internal.XppTypeImpl +import codeql.xpp.elements.Ast + +final class XppType = Impl::XppType; diff --git a/xpp/ql/lib/codeql/xpp/elements/XppTypeCompilationUnit.qll b/xpp/ql/lib/codeql/xpp/elements/XppTypeCompilationUnit.qll new file mode 100644 index 000000000000..1102272cffcb --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/XppTypeCompilationUnit.qll @@ -0,0 +1,10 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the public class `XppTypeCompilationUnit`. + */ + +private import internal.XppTypeCompilationUnitImpl +import codeql.xpp.elements.CompilationUnit +import codeql.xpp.elements.XppType + +final class XppTypeCompilationUnit = Impl::XppTypeCompilationUnit; diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/AddExpressionConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/AddExpressionConstructor.qll new file mode 100644 index 000000000000..8063e1e6876d --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/AddExpressionConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `AddExpression` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `AddExpression` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructAddExpression(Raw::AddExpression id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/AddExpressionImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/AddExpressionImpl.qll new file mode 100644 index 000000000000..4ede94b7fb99 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/AddExpressionImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `AddExpression`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.AddExpression + +/** + * INTERNAL: This module contains the customizable definition of `AddExpression` and should not + * be referenced directly. + */ +module Impl { + class AddExpression extends Generated::AddExpression { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/AggregateSelectionImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/AggregateSelectionImpl.qll new file mode 100644 index 000000000000..3a4c3af8b197 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/AggregateSelectionImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `AggregateSelection`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.AggregateSelection + +/** + * INTERNAL: This module contains the customizable definition of `AggregateSelection` and should not + * be referenced directly. + */ +module Impl { + class AggregateSelection extends Generated::AggregateSelection { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/AllFieldsSelectionConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/AllFieldsSelectionConstructor.qll new file mode 100644 index 000000000000..36e01c98c55e --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/AllFieldsSelectionConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `AllFieldsSelection` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `AllFieldsSelection` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructAllFieldsSelection(Raw::AllFieldsSelection id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/AllFieldsSelectionImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/AllFieldsSelectionImpl.qll new file mode 100644 index 000000000000..7325a928475a --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/AllFieldsSelectionImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `AllFieldsSelection`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.AllFieldsSelection + +/** + * INTERNAL: This module contains the customizable definition of `AllFieldsSelection` and should not + * be referenced directly. + */ +module Impl { + class AllFieldsSelection extends Generated::AllFieldsSelection { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/AndExpressionConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/AndExpressionConstructor.qll new file mode 100644 index 000000000000..37d3903edc40 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/AndExpressionConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `AndExpression` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `AndExpression` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructAndExpression(Raw::AndExpression id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/AndExpressionImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/AndExpressionImpl.qll new file mode 100644 index 000000000000..d9622ec247f7 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/AndExpressionImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `AndExpression`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.AndExpression + +/** + * INTERNAL: This module contains the customizable definition of `AndExpression` and should not + * be referenced directly. + */ +module Impl { + class AndExpression extends Generated::AndExpression { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/AnyTypeConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/AnyTypeConstructor.qll new file mode 100644 index 000000000000..a44956bef91d --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/AnyTypeConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `AnyType` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `AnyType` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructAnyType(Raw::AnyType id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/AnyTypeImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/AnyTypeImpl.qll new file mode 100644 index 000000000000..ba7151721305 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/AnyTypeImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `AnyType`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.AnyType + +/** + * INTERNAL: This module contains the customizable definition of `AnyType` and should not + * be referenced directly. + */ +module Impl { + class AnyType extends Generated::AnyType { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/ArraySpecificationConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/ArraySpecificationConstructor.qll new file mode 100644 index 000000000000..002f6ec686d4 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/ArraySpecificationConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `ArraySpecification` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `ArraySpecification` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructArraySpecification(Raw::ArraySpecification id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/ArraySpecificationImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/ArraySpecificationImpl.qll new file mode 100644 index 000000000000..b58abb4b0436 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/ArraySpecificationImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `ArraySpecification`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.ArraySpecification + +/** + * INTERNAL: This module contains the customizable definition of `ArraySpecification` and should not + * be referenced directly. + */ +module Impl { + class ArraySpecification extends Generated::ArraySpecification { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/AsClrExpressionConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/AsClrExpressionConstructor.qll new file mode 100644 index 000000000000..83c51de0bb7a --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/AsClrExpressionConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `AsClrExpression` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `AsClrExpression` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructAsClrExpression(Raw::AsClrExpression id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/AsClrExpressionImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/AsClrExpressionImpl.qll new file mode 100644 index 000000000000..887abf94230d --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/AsClrExpressionImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `AsClrExpression`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.AsClrExpression + +/** + * INTERNAL: This module contains the customizable definition of `AsClrExpression` and should not + * be referenced directly. + */ +module Impl { + class AsClrExpression extends Generated::AsClrExpression { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/AsExpressionConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/AsExpressionConstructor.qll new file mode 100644 index 000000000000..4004bd6148cd --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/AsExpressionConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `AsExpression` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `AsExpression` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructAsExpression(Raw::AsExpression id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/AsExpressionImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/AsExpressionImpl.qll new file mode 100644 index 000000000000..5365ab36fb6f --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/AsExpressionImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `AsExpression`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.AsExpression + +/** + * INTERNAL: This module contains the customizable definition of `AsExpression` and should not + * be referenced directly. + */ +module Impl { + class AsExpression extends Generated::AsExpression { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/AssignDecrementStatementConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/AssignDecrementStatementConstructor.qll new file mode 100644 index 000000000000..0ff9dd159a29 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/AssignDecrementStatementConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `AssignDecrementStatement` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `AssignDecrementStatement` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructAssignDecrementStatement(Raw::AssignDecrementStatement id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/AssignDecrementStatementImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/AssignDecrementStatementImpl.qll new file mode 100644 index 000000000000..25d98e07cb14 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/AssignDecrementStatementImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `AssignDecrementStatement`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.AssignDecrementStatement + +/** + * INTERNAL: This module contains the customizable definition of `AssignDecrementStatement` and should not + * be referenced directly. + */ +module Impl { + class AssignDecrementStatement extends Generated::AssignDecrementStatement { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/AssignDivideStatementConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/AssignDivideStatementConstructor.qll new file mode 100644 index 000000000000..e44e03c5caee --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/AssignDivideStatementConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `AssignDivideStatement` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `AssignDivideStatement` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructAssignDivideStatement(Raw::AssignDivideStatement id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/AssignDivideStatementImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/AssignDivideStatementImpl.qll new file mode 100644 index 000000000000..83fad4850086 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/AssignDivideStatementImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `AssignDivideStatement`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.AssignDivideStatement + +/** + * INTERNAL: This module contains the customizable definition of `AssignDivideStatement` and should not + * be referenced directly. + */ +module Impl { + class AssignDivideStatement extends Generated::AssignDivideStatement { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/AssignEqualStatementConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/AssignEqualStatementConstructor.qll new file mode 100644 index 000000000000..4200fa13d50c --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/AssignEqualStatementConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `AssignEqualStatement` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `AssignEqualStatement` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructAssignEqualStatement(Raw::AssignEqualStatement id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/AssignEqualStatementImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/AssignEqualStatementImpl.qll new file mode 100644 index 000000000000..a32547acf669 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/AssignEqualStatementImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `AssignEqualStatement`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.AssignEqualStatement + +/** + * INTERNAL: This module contains the customizable definition of `AssignEqualStatement` and should not + * be referenced directly. + */ +module Impl { + class AssignEqualStatement extends Generated::AssignEqualStatement { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/AssignIncrementStatementConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/AssignIncrementStatementConstructor.qll new file mode 100644 index 000000000000..39338a21e2b4 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/AssignIncrementStatementConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `AssignIncrementStatement` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `AssignIncrementStatement` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructAssignIncrementStatement(Raw::AssignIncrementStatement id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/AssignIncrementStatementImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/AssignIncrementStatementImpl.qll new file mode 100644 index 000000000000..402e294edcb0 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/AssignIncrementStatementImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `AssignIncrementStatement`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.AssignIncrementStatement + +/** + * INTERNAL: This module contains the customizable definition of `AssignIncrementStatement` and should not + * be referenced directly. + */ +module Impl { + class AssignIncrementStatement extends Generated::AssignIncrementStatement { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/AssignMultipleFieldStatementConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/AssignMultipleFieldStatementConstructor.qll new file mode 100644 index 000000000000..9912409d4ffc --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/AssignMultipleFieldStatementConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `AssignMultipleFieldStatement` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `AssignMultipleFieldStatement` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructAssignMultipleFieldStatement(Raw::AssignMultipleFieldStatement id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/AssignMultipleFieldStatementImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/AssignMultipleFieldStatementImpl.qll new file mode 100644 index 000000000000..9ab48fd23ccb --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/AssignMultipleFieldStatementImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `AssignMultipleFieldStatement`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.AssignMultipleFieldStatement + +/** + * INTERNAL: This module contains the customizable definition of `AssignMultipleFieldStatement` and should not + * be referenced directly. + */ +module Impl { + class AssignMultipleFieldStatement extends Generated::AssignMultipleFieldStatement { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/AssignMultiplyStatementConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/AssignMultiplyStatementConstructor.qll new file mode 100644 index 000000000000..4cd25378a16a --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/AssignMultiplyStatementConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `AssignMultiplyStatement` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `AssignMultiplyStatement` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructAssignMultiplyStatement(Raw::AssignMultiplyStatement id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/AssignMultiplyStatementImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/AssignMultiplyStatementImpl.qll new file mode 100644 index 000000000000..a03dcc487178 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/AssignMultiplyStatementImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `AssignMultiplyStatement`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.AssignMultiplyStatement + +/** + * INTERNAL: This module contains the customizable definition of `AssignMultiplyStatement` and should not + * be referenced directly. + */ +module Impl { + class AssignMultiplyStatement extends Generated::AssignMultiplyStatement { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/AssignPostDecrementStatementConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/AssignPostDecrementStatementConstructor.qll new file mode 100644 index 000000000000..2df7c417bae6 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/AssignPostDecrementStatementConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `AssignPostDecrementStatement` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `AssignPostDecrementStatement` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructAssignPostDecrementStatement(Raw::AssignPostDecrementStatement id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/AssignPostDecrementStatementImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/AssignPostDecrementStatementImpl.qll new file mode 100644 index 000000000000..7cac14b3dc89 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/AssignPostDecrementStatementImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `AssignPostDecrementStatement`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.AssignPostDecrementStatement + +/** + * INTERNAL: This module contains the customizable definition of `AssignPostDecrementStatement` and should not + * be referenced directly. + */ +module Impl { + class AssignPostDecrementStatement extends Generated::AssignPostDecrementStatement { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/AssignPostIncrementStatementConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/AssignPostIncrementStatementConstructor.qll new file mode 100644 index 000000000000..f935f91dc91c --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/AssignPostIncrementStatementConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `AssignPostIncrementStatement` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `AssignPostIncrementStatement` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructAssignPostIncrementStatement(Raw::AssignPostIncrementStatement id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/AssignPostIncrementStatementImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/AssignPostIncrementStatementImpl.qll new file mode 100644 index 000000000000..b82935841daf --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/AssignPostIncrementStatementImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `AssignPostIncrementStatement`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.AssignPostIncrementStatement + +/** + * INTERNAL: This module contains the customizable definition of `AssignPostIncrementStatement` and should not + * be referenced directly. + */ +module Impl { + class AssignPostIncrementStatement extends Generated::AssignPostIncrementStatement { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/AssignPreDecrementStatementConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/AssignPreDecrementStatementConstructor.qll new file mode 100644 index 000000000000..0a87051ccba6 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/AssignPreDecrementStatementConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `AssignPreDecrementStatement` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `AssignPreDecrementStatement` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructAssignPreDecrementStatement(Raw::AssignPreDecrementStatement id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/AssignPreDecrementStatementImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/AssignPreDecrementStatementImpl.qll new file mode 100644 index 000000000000..2bf5edab429e --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/AssignPreDecrementStatementImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `AssignPreDecrementStatement`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.AssignPreDecrementStatement + +/** + * INTERNAL: This module contains the customizable definition of `AssignPreDecrementStatement` and should not + * be referenced directly. + */ +module Impl { + class AssignPreDecrementStatement extends Generated::AssignPreDecrementStatement { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/AssignPreIncrementStatementConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/AssignPreIncrementStatementConstructor.qll new file mode 100644 index 000000000000..027261f65931 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/AssignPreIncrementStatementConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `AssignPreIncrementStatement` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `AssignPreIncrementStatement` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructAssignPreIncrementStatement(Raw::AssignPreIncrementStatement id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/AssignPreIncrementStatementImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/AssignPreIncrementStatementImpl.qll new file mode 100644 index 000000000000..26471eb4f9cc --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/AssignPreIncrementStatementImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `AssignPreIncrementStatement`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.AssignPreIncrementStatement + +/** + * INTERNAL: This module contains the customizable definition of `AssignPreIncrementStatement` and should not + * be referenced directly. + */ +module Impl { + class AssignPreIncrementStatement extends Generated::AssignPreIncrementStatement { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/AssignmentBinaryImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/AssignmentBinaryImpl.qll new file mode 100644 index 000000000000..fc2cf397d167 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/AssignmentBinaryImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `AssignmentBinary`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.AssignmentBinary + +/** + * INTERNAL: This module contains the customizable definition of `AssignmentBinary` and should not + * be referenced directly. + */ +module Impl { + class AssignmentBinary extends Generated::AssignmentBinary { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/AssignmentEventHandlerBaseImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/AssignmentEventHandlerBaseImpl.qll new file mode 100644 index 000000000000..e41249ee24e9 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/AssignmentEventHandlerBaseImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `AssignmentEventHandlerBase`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.AssignmentEventHandlerBase + +/** + * INTERNAL: This module contains the customizable definition of `AssignmentEventHandlerBase` and should not + * be referenced directly. + */ +module Impl { + class AssignmentEventHandlerBase extends Generated::AssignmentEventHandlerBase { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/AssignmentEventHandlerClrConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/AssignmentEventHandlerClrConstructor.qll new file mode 100644 index 000000000000..e4d33dc66ca2 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/AssignmentEventHandlerClrConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `AssignmentEventHandlerClr` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `AssignmentEventHandlerClr` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructAssignmentEventHandlerClr(Raw::AssignmentEventHandlerClr id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/AssignmentEventHandlerClrImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/AssignmentEventHandlerClrImpl.qll new file mode 100644 index 000000000000..833a6f5abcbc --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/AssignmentEventHandlerClrImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `AssignmentEventHandlerClr`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.AssignmentEventHandlerClr + +/** + * INTERNAL: This module contains the customizable definition of `AssignmentEventHandlerClr` and should not + * be referenced directly. + */ +module Impl { + class AssignmentEventHandlerClr extends Generated::AssignmentEventHandlerClr { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/AssignmentEventHandlerInstanceConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/AssignmentEventHandlerInstanceConstructor.qll new file mode 100644 index 000000000000..8607a36445f2 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/AssignmentEventHandlerInstanceConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `AssignmentEventHandlerInstance` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `AssignmentEventHandlerInstance` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructAssignmentEventHandlerInstance(Raw::AssignmentEventHandlerInstance id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/AssignmentEventHandlerInstanceImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/AssignmentEventHandlerInstanceImpl.qll new file mode 100644 index 000000000000..65ef46f7983b --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/AssignmentEventHandlerInstanceImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `AssignmentEventHandlerInstance`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.AssignmentEventHandlerInstance + +/** + * INTERNAL: This module contains the customizable definition of `AssignmentEventHandlerInstance` and should not + * be referenced directly. + */ +module Impl { + class AssignmentEventHandlerInstance extends Generated::AssignmentEventHandlerInstance { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/AssignmentEventHandlerStaticImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/AssignmentEventHandlerStaticImpl.qll new file mode 100644 index 000000000000..8672b14fa881 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/AssignmentEventHandlerStaticImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `AssignmentEventHandlerStatic`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.AssignmentEventHandlerStatic + +/** + * INTERNAL: This module contains the customizable definition of `AssignmentEventHandlerStatic` and should not + * be referenced directly. + */ +module Impl { + class AssignmentEventHandlerStatic extends Generated::AssignmentEventHandlerStatic { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/AssignmentEventHandlerStaticInternalConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/AssignmentEventHandlerStaticInternalConstructor.qll new file mode 100644 index 000000000000..a6fa9f463959 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/AssignmentEventHandlerStaticInternalConstructor.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `AssignmentEventHandlerStaticInternal` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `AssignmentEventHandlerStaticInternal` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructAssignmentEventHandlerStaticInternal(Raw::AssignmentEventHandlerStaticInternal id) { + any() +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/AssignmentEventHandlerStaticInternalImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/AssignmentEventHandlerStaticInternalImpl.qll new file mode 100644 index 000000000000..975f0750731c --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/AssignmentEventHandlerStaticInternalImpl.qll @@ -0,0 +1,17 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `AssignmentEventHandlerStaticInternal`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.AssignmentEventHandlerStaticInternal + +/** + * INTERNAL: This module contains the customizable definition of `AssignmentEventHandlerStaticInternal` and should not + * be referenced directly. + */ +module Impl { + class AssignmentEventHandlerStaticInternal extends Generated::AssignmentEventHandlerStaticInternal + { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/AssignmentSingleFieldImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/AssignmentSingleFieldImpl.qll new file mode 100644 index 000000000000..ad70c6657b64 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/AssignmentSingleFieldImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `AssignmentSingleField`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.AssignmentSingleField + +/** + * INTERNAL: This module contains the customizable definition of `AssignmentSingleField` and should not + * be referenced directly. + */ +module Impl { + class AssignmentSingleField extends Generated::AssignmentSingleField { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/AssignmentStatementImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/AssignmentStatementImpl.qll new file mode 100644 index 000000000000..502ebcfcbf68 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/AssignmentStatementImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `AssignmentStatement`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.AssignmentStatement + +/** + * INTERNAL: This module contains the customizable definition of `AssignmentStatement` and should not + * be referenced directly. + */ +module Impl { + class AssignmentStatement extends Generated::AssignmentStatement { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/AstImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/AstImpl.qll new file mode 100644 index 000000000000..f0f967228815 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/AstImpl.qll @@ -0,0 +1,22 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `Ast`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Ast + +/** + * INTERNAL: This module contains the customizable definition of `Ast` and should not + * be referenced directly. + */ +module Impl { + /** + * Root of the X++ abstract syntax tree. + * + * This mirrors `Microsoft.Dynamics.AX.Metadata.XppCompiler.Ast`, the base class of the + * X++ compiler's own AST. + */ + class Ast extends Generated::Ast { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/AttributeConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/AttributeConstructor.qll new file mode 100644 index 000000000000..ac71e392dd78 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/AttributeConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `Attribute` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `Attribute` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructAttribute(Raw::Attribute id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/AttributeExpressionConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/AttributeExpressionConstructor.qll new file mode 100644 index 000000000000..b0fcf52cc5c2 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/AttributeExpressionConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `AttributeExpression` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `AttributeExpression` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructAttributeExpression(Raw::AttributeExpression id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/AttributeExpressionImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/AttributeExpressionImpl.qll new file mode 100644 index 000000000000..7c59b699cfc9 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/AttributeExpressionImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `AttributeExpression`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.AttributeExpression + +/** + * INTERNAL: This module contains the customizable definition of `AttributeExpression` and should not + * be referenced directly. + */ +module Impl { + class AttributeExpression extends Generated::AttributeExpression { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/AttributeImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/AttributeImpl.qll new file mode 100644 index 000000000000..319922c4163a --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/AttributeImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `Attribute`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Attribute + +/** + * INTERNAL: This module contains the customizable definition of `Attribute` and should not + * be referenced directly. + */ +module Impl { + class Attribute extends Generated::Attribute { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/AttributeListConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/AttributeListConstructor.qll new file mode 100644 index 000000000000..8e5ff41193b9 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/AttributeListConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `AttributeList` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `AttributeList` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructAttributeList(Raw::AttributeList id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/AttributeListImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/AttributeListImpl.qll new file mode 100644 index 000000000000..6a38164a49fb --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/AttributeListImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `AttributeList`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.AttributeList + +/** + * INTERNAL: This module contains the customizable definition of `AttributeList` and should not + * be referenced directly. + */ +module Impl { + class AttributeList extends Generated::AttributeList { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/AttributeLiteralImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/AttributeLiteralImpl.qll new file mode 100644 index 000000000000..6dced5d52b6a --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/AttributeLiteralImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `AttributeLiteral`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.AttributeLiteral + +/** + * INTERNAL: This module contains the customizable definition of `AttributeLiteral` and should not + * be referenced directly. + */ +module Impl { + class AttributeLiteral extends Generated::AttributeLiteral { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/AttributeNamedParameterEntryConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/AttributeNamedParameterEntryConstructor.qll new file mode 100644 index 000000000000..42816bc8cd59 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/AttributeNamedParameterEntryConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `AttributeNamedParameterEntry` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `AttributeNamedParameterEntry` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructAttributeNamedParameterEntry(Raw::AttributeNamedParameterEntry id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/AttributeNamedParameterEntryImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/AttributeNamedParameterEntryImpl.qll new file mode 100644 index 000000000000..b2893fa9a338 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/AttributeNamedParameterEntryImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `AttributeNamedParameterEntry`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.AttributeNamedParameterEntry + +/** + * INTERNAL: This module contains the customizable definition of `AttributeNamedParameterEntry` and should not + * be referenced directly. + */ +module Impl { + class AttributeNamedParameterEntry extends Generated::AttributeNamedParameterEntry { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/AvgAggregateSelectionConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/AvgAggregateSelectionConstructor.qll new file mode 100644 index 000000000000..63fad739b95d --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/AvgAggregateSelectionConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `AvgAggregateSelection` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `AvgAggregateSelection` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructAvgAggregateSelection(Raw::AvgAggregateSelection id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/AvgAggregateSelectionImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/AvgAggregateSelectionImpl.qll new file mode 100644 index 000000000000..8d9b855f340b --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/AvgAggregateSelectionImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `AvgAggregateSelection`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.AvgAggregateSelection + +/** + * INTERNAL: This module contains the customizable definition of `AvgAggregateSelection` and should not + * be referenced directly. + */ +module Impl { + class AvgAggregateSelection extends Generated::AvgAggregateSelection { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/BinaryExpressionImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/BinaryExpressionImpl.qll new file mode 100644 index 000000000000..fa00ffb2f912 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/BinaryExpressionImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `BinaryExpression`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.BinaryExpression + +/** + * INTERNAL: This module contains the customizable definition of `BinaryExpression` and should not + * be referenced directly. + */ +module Impl { + class BinaryExpression extends Generated::BinaryExpression { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/BooleanAttributeLiteralConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/BooleanAttributeLiteralConstructor.qll new file mode 100644 index 000000000000..f1104b5564a5 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/BooleanAttributeLiteralConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `BooleanAttributeLiteral` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `BooleanAttributeLiteral` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructBooleanAttributeLiteral(Raw::BooleanAttributeLiteral id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/BooleanAttributeLiteralImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/BooleanAttributeLiteralImpl.qll new file mode 100644 index 000000000000..b5b920468346 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/BooleanAttributeLiteralImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `BooleanAttributeLiteral`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.BooleanAttributeLiteral + +/** + * INTERNAL: This module contains the customizable definition of `BooleanAttributeLiteral` and should not + * be referenced directly. + */ +module Impl { + class BooleanAttributeLiteral extends Generated::BooleanAttributeLiteral { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/BooleanLiteralExpressionConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/BooleanLiteralExpressionConstructor.qll new file mode 100644 index 000000000000..585da6b88356 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/BooleanLiteralExpressionConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `BooleanLiteralExpression` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `BooleanLiteralExpression` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructBooleanLiteralExpression(Raw::BooleanLiteralExpression id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/BooleanLiteralExpressionImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/BooleanLiteralExpressionImpl.qll new file mode 100644 index 000000000000..ea0c3e6c2adf --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/BooleanLiteralExpressionImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `BooleanLiteralExpression`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.BooleanLiteralExpression + +/** + * INTERNAL: This module contains the customizable definition of `BooleanLiteralExpression` and should not + * be referenced directly. + */ +module Impl { + class BooleanLiteralExpression extends Generated::BooleanLiteralExpression { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/BooleanTypeConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/BooleanTypeConstructor.qll new file mode 100644 index 000000000000..18a2e4b2a887 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/BooleanTypeConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `BooleanType` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `BooleanType` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructBooleanType(Raw::BooleanType id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/BooleanTypeImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/BooleanTypeImpl.qll new file mode 100644 index 000000000000..2411cdfa29bb --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/BooleanTypeImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `BooleanType`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.BooleanType + +/** + * INTERNAL: This module contains the customizable definition of `BooleanType` and should not + * be referenced directly. + */ +module Impl { + class BooleanType extends Generated::BooleanType { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/BreakStatementConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/BreakStatementConstructor.qll new file mode 100644 index 000000000000..f2f0865c1080 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/BreakStatementConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `BreakStatement` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `BreakStatement` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructBreakStatement(Raw::BreakStatement id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/BreakStatementImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/BreakStatementImpl.qll new file mode 100644 index 000000000000..5cdee457f756 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/BreakStatementImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `BreakStatement`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.BreakStatement + +/** + * INTERNAL: This module contains the customizable definition of `BreakStatement` and should not + * be referenced directly. + */ +module Impl { + class BreakStatement extends Generated::BreakStatement { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/BreakpointStatementConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/BreakpointStatementConstructor.qll new file mode 100644 index 000000000000..10cc0393c961 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/BreakpointStatementConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `BreakpointStatement` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `BreakpointStatement` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructBreakpointStatement(Raw::BreakpointStatement id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/BreakpointStatementImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/BreakpointStatementImpl.qll new file mode 100644 index 000000000000..b04ea6d888cd --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/BreakpointStatementImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `BreakpointStatement`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.BreakpointStatement + +/** + * INTERNAL: This module contains the customizable definition of `BreakpointStatement` and should not + * be referenced directly. + */ +module Impl { + class BreakpointStatement extends Generated::BreakpointStatement { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/CaseDefaultConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/CaseDefaultConstructor.qll new file mode 100644 index 000000000000..084927d33a54 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/CaseDefaultConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `CaseDefault` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `CaseDefault` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructCaseDefault(Raw::CaseDefault id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/CaseDefaultImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/CaseDefaultImpl.qll new file mode 100644 index 000000000000..e7d72828955d --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/CaseDefaultImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `CaseDefault`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.CaseDefault + +/** + * INTERNAL: This module contains the customizable definition of `CaseDefault` and should not + * be referenced directly. + */ +module Impl { + class CaseDefault extends Generated::CaseDefault { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/CaseImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/CaseImpl.qll new file mode 100644 index 000000000000..f248ec6a16e8 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/CaseImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `Case`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Case + +/** + * INTERNAL: This module contains the customizable definition of `Case` and should not + * be referenced directly. + */ +module Impl { + class Case extends Generated::Case { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/CaseValuesConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/CaseValuesConstructor.qll new file mode 100644 index 000000000000..32285f414381 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/CaseValuesConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `CaseValues` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `CaseValues` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructCaseValues(Raw::CaseValues id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/CaseValuesImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/CaseValuesImpl.qll new file mode 100644 index 000000000000..0c6f614d4214 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/CaseValuesImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `CaseValues`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.CaseValues + +/** + * INTERNAL: This module contains the customizable definition of `CaseValues` and should not + * be referenced directly. + */ +module Impl { + class CaseValues extends Generated::CaseValues { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/CatchAllValuesConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/CatchAllValuesConstructor.qll new file mode 100644 index 000000000000..11c30002d144 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/CatchAllValuesConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `CatchAllValues` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `CatchAllValues` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructCatchAllValues(Raw::CatchAllValues id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/CatchAllValuesImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/CatchAllValuesImpl.qll new file mode 100644 index 000000000000..ce0ca8ac6078 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/CatchAllValuesImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `CatchAllValues`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.CatchAllValues + +/** + * INTERNAL: This module contains the customizable definition of `CatchAllValues` and should not + * be referenced directly. + */ +module Impl { + class CatchAllValues extends Generated::CatchAllValues { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/CatchExpressionConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/CatchExpressionConstructor.qll new file mode 100644 index 000000000000..51b3cd9c5a5e --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/CatchExpressionConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `CatchExpression` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `CatchExpression` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructCatchExpression(Raw::CatchExpression id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/CatchExpressionImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/CatchExpressionImpl.qll new file mode 100644 index 000000000000..f310997a4627 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/CatchExpressionImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `CatchExpression`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.CatchExpression + +/** + * INTERNAL: This module contains the customizable definition of `CatchExpression` and should not + * be referenced directly. + */ +module Impl { + class CatchExpression extends Generated::CatchExpression { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/CatchImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/CatchImpl.qll new file mode 100644 index 000000000000..9ce96b4a5f9d --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/CatchImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `Catch`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Catch + +/** + * INTERNAL: This module contains the customizable definition of `Catch` and should not + * be referenced directly. + */ +module Impl { + class Catch extends Generated::Catch { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/CatchUpdateConflictConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/CatchUpdateConflictConstructor.qll new file mode 100644 index 000000000000..7dd9fe4f68df --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/CatchUpdateConflictConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `CatchUpdateConflict` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `CatchUpdateConflict` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructCatchUpdateConflict(Raw::CatchUpdateConflict id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/CatchUpdateConflictImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/CatchUpdateConflictImpl.qll new file mode 100644 index 000000000000..b7495d974005 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/CatchUpdateConflictImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `CatchUpdateConflict`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.CatchUpdateConflict + +/** + * INTERNAL: This module contains the customizable definition of `CatchUpdateConflict` and should not + * be referenced directly. + */ +module Impl { + class CatchUpdateConflict extends Generated::CatchUpdateConflict { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/ChangeCompanyStatementConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/ChangeCompanyStatementConstructor.qll new file mode 100644 index 000000000000..b5c47e7d24f7 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/ChangeCompanyStatementConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `ChangeCompanyStatement` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `ChangeCompanyStatement` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructChangeCompanyStatement(Raw::ChangeCompanyStatement id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/ChangeCompanyStatementImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/ChangeCompanyStatementImpl.qll new file mode 100644 index 000000000000..59ddb3fc68f6 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/ChangeCompanyStatementImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `ChangeCompanyStatement`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.ChangeCompanyStatement + +/** + * INTERNAL: This module contains the customizable definition of `ChangeCompanyStatement` and should not + * be referenced directly. + */ +module Impl { + class ChangeCompanyStatement extends Generated::ChangeCompanyStatement { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/ChangeStatementImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/ChangeStatementImpl.qll new file mode 100644 index 000000000000..7427bd864f57 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/ChangeStatementImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `ChangeStatement`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.ChangeStatement + +/** + * INTERNAL: This module contains the customizable definition of `ChangeStatement` and should not + * be referenced directly. + */ +module Impl { + class ChangeStatement extends Generated::ChangeStatement { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/ClassAccessModifierConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/ClassAccessModifierConstructor.qll new file mode 100644 index 000000000000..189c011855d8 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/ClassAccessModifierConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `ClassAccessModifier` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `ClassAccessModifier` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructClassAccessModifier(Raw::ClassAccessModifier id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/ClassAccessModifierImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/ClassAccessModifierImpl.qll new file mode 100644 index 000000000000..9ad35472b122 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/ClassAccessModifierImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `ClassAccessModifier`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.ClassAccessModifier + +/** + * INTERNAL: This module contains the customizable definition of `ClassAccessModifier` and should not + * be referenced directly. + */ +module Impl { + class ClassAccessModifier extends Generated::ClassAccessModifier { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/ClassConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/ClassConstructor.qll new file mode 100644 index 000000000000..0684ad6db5f8 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/ClassConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `Class` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `Class` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructClass(Raw::Class id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/ClassImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/ClassImpl.qll new file mode 100644 index 000000000000..ce46ff557cb7 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/ClassImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `Class`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Class + +/** + * INTERNAL: This module contains the customizable definition of `Class` and should not + * be referenced directly. + */ +module Impl { + class Class extends Generated::Class { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/ClassOrInterfaceImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/ClassOrInterfaceImpl.qll new file mode 100644 index 000000000000..b1b6e49ef8c5 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/ClassOrInterfaceImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `ClassOrInterface`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.ClassOrInterface + +/** + * INTERNAL: This module contains the customizable definition of `ClassOrInterface` and should not + * be referenced directly. + */ +module Impl { + class ClassOrInterface extends Generated::ClassOrInterface { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/ClrEnumerationLiteralExpressionConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/ClrEnumerationLiteralExpressionConstructor.qll new file mode 100644 index 000000000000..40cad9d91f46 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/ClrEnumerationLiteralExpressionConstructor.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `ClrEnumerationLiteralExpression` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `ClrEnumerationLiteralExpression` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructClrEnumerationLiteralExpression(Raw::ClrEnumerationLiteralExpression id) { + any() +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/ClrEnumerationLiteralExpressionImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/ClrEnumerationLiteralExpressionImpl.qll new file mode 100644 index 000000000000..96538d05ecf8 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/ClrEnumerationLiteralExpressionImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `ClrEnumerationLiteralExpression`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.ClrEnumerationLiteralExpression + +/** + * INTERNAL: This module contains the customizable definition of `ClrEnumerationLiteralExpression` and should not + * be referenced directly. + */ +module Impl { + class ClrEnumerationLiteralExpression extends Generated::ClrEnumerationLiteralExpression { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/ClrTypeConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/ClrTypeConstructor.qll new file mode 100644 index 000000000000..f28d029e260b --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/ClrTypeConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `ClrType` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `ClrType` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructClrType(Raw::ClrType id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/ClrTypeImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/ClrTypeImpl.qll new file mode 100644 index 000000000000..c7aeada8eb28 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/ClrTypeImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `ClrType`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.ClrType + +/** + * INTERNAL: This module contains the customizable definition of `ClrType` and should not + * be referenced directly. + */ +module Impl { + class ClrType extends Generated::ClrType { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/CommentConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/CommentConstructor.qll new file mode 100644 index 000000000000..7e3a41fb369e --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/CommentConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `Comment` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `Comment` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructComment(Raw::Comment id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/CommentImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/CommentImpl.qll new file mode 100644 index 000000000000..1cb8a7a04ca7 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/CommentImpl.qll @@ -0,0 +1,19 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `Comment`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Comment + +/** + * INTERNAL: This module contains the customizable definition of `Comment` and should not + * be referenced directly. + */ +module Impl { + /** + * A comment in X++ source. + */ + class Comment extends Generated::Comment { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/CompilationUnitImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/CompilationUnitImpl.qll new file mode 100644 index 000000000000..f65da955ebb5 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/CompilationUnitImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `CompilationUnit`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.CompilationUnit + +/** + * INTERNAL: This module contains the customizable definition of `CompilationUnit` and should not + * be referenced directly. + */ +module Impl { + class CompilationUnit extends Generated::CompilationUnit { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/CompilationUnitRegionEntryConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/CompilationUnitRegionEntryConstructor.qll new file mode 100644 index 000000000000..90a62c21b093 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/CompilationUnitRegionEntryConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `CompilationUnitRegionEntry` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `CompilationUnitRegionEntry` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructCompilationUnitRegionEntry(Raw::CompilationUnitRegionEntry id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/CompilationUnitRegionEntryImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/CompilationUnitRegionEntryImpl.qll new file mode 100644 index 000000000000..ce27e750eecd --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/CompilationUnitRegionEntryImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `CompilationUnitRegionEntry`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.CompilationUnitRegionEntry + +/** + * INTERNAL: This module contains the customizable definition of `CompilationUnitRegionEntry` and should not + * be referenced directly. + */ +module Impl { + class CompilationUnitRegionEntry extends Generated::CompilationUnitRegionEntry { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/CompoundStatementConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/CompoundStatementConstructor.qll new file mode 100644 index 000000000000..b2de6fc21672 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/CompoundStatementConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `CompoundStatement` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `CompoundStatement` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructCompoundStatement(Raw::CompoundStatement id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/CompoundStatementImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/CompoundStatementImpl.qll new file mode 100644 index 000000000000..6a9585da6af8 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/CompoundStatementImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `CompoundStatement`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.CompoundStatement + +/** + * INTERNAL: This module contains the customizable definition of `CompoundStatement` and should not + * be referenced directly. + */ +module Impl { + class CompoundStatement extends Generated::CompoundStatement { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/ConditionalExpressionConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/ConditionalExpressionConstructor.qll new file mode 100644 index 000000000000..11cf13b6d4bd --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/ConditionalExpressionConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `ConditionalExpression` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `ConditionalExpression` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructConditionalExpression(Raw::ConditionalExpression id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/ConditionalExpressionImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/ConditionalExpressionImpl.qll new file mode 100644 index 000000000000..d59be3561ead --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/ConditionalExpressionImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `ConditionalExpression`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.ConditionalExpression + +/** + * INTERNAL: This module contains the customizable definition of `ConditionalExpression` and should not + * be referenced directly. + */ +module Impl { + class ConditionalExpression extends Generated::ConditionalExpression { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/ContainerAttributeLiteralConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/ContainerAttributeLiteralConstructor.qll new file mode 100644 index 000000000000..bceedf6c066c --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/ContainerAttributeLiteralConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `ContainerAttributeLiteral` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `ContainerAttributeLiteral` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructContainerAttributeLiteral(Raw::ContainerAttributeLiteral id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/ContainerAttributeLiteralImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/ContainerAttributeLiteralImpl.qll new file mode 100644 index 000000000000..7852392834d2 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/ContainerAttributeLiteralImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `ContainerAttributeLiteral`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.ContainerAttributeLiteral + +/** + * INTERNAL: This module contains the customizable definition of `ContainerAttributeLiteral` and should not + * be referenced directly. + */ +module Impl { + class ContainerAttributeLiteral extends Generated::ContainerAttributeLiteral { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/ContainerLiteralExpressionConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/ContainerLiteralExpressionConstructor.qll new file mode 100644 index 000000000000..f13784029545 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/ContainerLiteralExpressionConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `ContainerLiteralExpression` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `ContainerLiteralExpression` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructContainerLiteralExpression(Raw::ContainerLiteralExpression id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/ContainerLiteralExpressionImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/ContainerLiteralExpressionImpl.qll new file mode 100644 index 000000000000..5598c9af0ce2 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/ContainerLiteralExpressionImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `ContainerLiteralExpression`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.ContainerLiteralExpression + +/** + * INTERNAL: This module contains the customizable definition of `ContainerLiteralExpression` and should not + * be referenced directly. + */ +module Impl { + class ContainerLiteralExpression extends Generated::ContainerLiteralExpression { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/ContainerTypeConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/ContainerTypeConstructor.qll new file mode 100644 index 000000000000..3f877294f986 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/ContainerTypeConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `ContainerType` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `ContainerType` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructContainerType(Raw::ContainerType id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/ContainerTypeImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/ContainerTypeImpl.qll new file mode 100644 index 000000000000..24e5757de8f7 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/ContainerTypeImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `ContainerType`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.ContainerType + +/** + * INTERNAL: This module contains the customizable definition of `ContainerType` and should not + * be referenced directly. + */ +module Impl { + class ContainerType extends Generated::ContainerType { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/ContinueStatementConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/ContinueStatementConstructor.qll new file mode 100644 index 000000000000..6b835c2bc220 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/ContinueStatementConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `ContinueStatement` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `ContinueStatement` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructContinueStatement(Raw::ContinueStatement id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/ContinueStatementImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/ContinueStatementImpl.qll new file mode 100644 index 000000000000..cb17ff553d0d --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/ContinueStatementImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `ContinueStatement`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.ContinueStatement + +/** + * INTERNAL: This module contains the customizable definition of `ContinueStatement` and should not + * be referenced directly. + */ +module Impl { + class ContinueStatement extends Generated::ContinueStatement { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/CountAggregateSelectionConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/CountAggregateSelectionConstructor.qll new file mode 100644 index 000000000000..038c2f2b56da --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/CountAggregateSelectionConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `CountAggregateSelection` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `CountAggregateSelection` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructCountAggregateSelection(Raw::CountAggregateSelection id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/CountAggregateSelectionImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/CountAggregateSelectionImpl.qll new file mode 100644 index 000000000000..73ac46404c2e --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/CountAggregateSelectionImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `CountAggregateSelection`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.CountAggregateSelection + +/** + * INTERNAL: This module contains the customizable definition of `CountAggregateSelection` and should not + * be referenced directly. + */ +module Impl { + class CountAggregateSelection extends Generated::CountAggregateSelection { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/CrossCompanyAllConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/CrossCompanyAllConstructor.qll new file mode 100644 index 000000000000..1024d810a7ec --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/CrossCompanyAllConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `CrossCompanyAll` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `CrossCompanyAll` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructCrossCompanyAll(Raw::CrossCompanyAll id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/CrossCompanyAllImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/CrossCompanyAllImpl.qll new file mode 100644 index 000000000000..cfe28bb5363c --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/CrossCompanyAllImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `CrossCompanyAll`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.CrossCompanyAll + +/** + * INTERNAL: This module contains the customizable definition of `CrossCompanyAll` and should not + * be referenced directly. + */ +module Impl { + class CrossCompanyAll extends Generated::CrossCompanyAll { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/CrossCompanyContainerConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/CrossCompanyContainerConstructor.qll new file mode 100644 index 000000000000..66c64098a215 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/CrossCompanyContainerConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `CrossCompanyContainer` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `CrossCompanyContainer` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructCrossCompanyContainer(Raw::CrossCompanyContainer id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/CrossCompanyContainerImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/CrossCompanyContainerImpl.qll new file mode 100644 index 000000000000..ac86fc363efc --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/CrossCompanyContainerImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `CrossCompanyContainer`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.CrossCompanyContainer + +/** + * INTERNAL: This module contains the customizable definition of `CrossCompanyContainer` and should not + * be referenced directly. + */ +module Impl { + class CrossCompanyContainer extends Generated::CrossCompanyContainer { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/CrossCompanyImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/CrossCompanyImpl.qll new file mode 100644 index 000000000000..c32305b5ec0e --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/CrossCompanyImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `CrossCompany`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.CrossCompany + +/** + * INTERNAL: This module contains the customizable definition of `CrossCompany` and should not + * be referenced directly. + */ +module Impl { + class CrossCompany extends Generated::CrossCompany { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/DateAttributeLiteralConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/DateAttributeLiteralConstructor.qll new file mode 100644 index 000000000000..319e5329faa4 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/DateAttributeLiteralConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `DateAttributeLiteral` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `DateAttributeLiteral` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructDateAttributeLiteral(Raw::DateAttributeLiteral id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/DateAttributeLiteralImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/DateAttributeLiteralImpl.qll new file mode 100644 index 000000000000..2223023e72db --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/DateAttributeLiteralImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `DateAttributeLiteral`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.DateAttributeLiteral + +/** + * INTERNAL: This module contains the customizable definition of `DateAttributeLiteral` and should not + * be referenced directly. + */ +module Impl { + class DateAttributeLiteral extends Generated::DateAttributeLiteral { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/DateLiteralExpressionConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/DateLiteralExpressionConstructor.qll new file mode 100644 index 000000000000..86289945000d --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/DateLiteralExpressionConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `DateLiteralExpression` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `DateLiteralExpression` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructDateLiteralExpression(Raw::DateLiteralExpression id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/DateLiteralExpressionImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/DateLiteralExpressionImpl.qll new file mode 100644 index 000000000000..ca60687e8a22 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/DateLiteralExpressionImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `DateLiteralExpression`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.DateLiteralExpression + +/** + * INTERNAL: This module contains the customizable definition of `DateLiteralExpression` and should not + * be referenced directly. + */ +module Impl { + class DateLiteralExpression extends Generated::DateLiteralExpression { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/DateTimeAttributeLiteralConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/DateTimeAttributeLiteralConstructor.qll new file mode 100644 index 000000000000..b0985698b6cb --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/DateTimeAttributeLiteralConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `DateTimeAttributeLiteral` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `DateTimeAttributeLiteral` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructDateTimeAttributeLiteral(Raw::DateTimeAttributeLiteral id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/DateTimeAttributeLiteralImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/DateTimeAttributeLiteralImpl.qll new file mode 100644 index 000000000000..207e69bd0364 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/DateTimeAttributeLiteralImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `DateTimeAttributeLiteral`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.DateTimeAttributeLiteral + +/** + * INTERNAL: This module contains the customizable definition of `DateTimeAttributeLiteral` and should not + * be referenced directly. + */ +module Impl { + class DateTimeAttributeLiteral extends Generated::DateTimeAttributeLiteral { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/DateTimeLiteralExpressionConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/DateTimeLiteralExpressionConstructor.qll new file mode 100644 index 000000000000..a8028d0bad0e --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/DateTimeLiteralExpressionConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `DateTimeLiteralExpression` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `DateTimeLiteralExpression` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructDateTimeLiteralExpression(Raw::DateTimeLiteralExpression id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/DateTimeLiteralExpressionImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/DateTimeLiteralExpressionImpl.qll new file mode 100644 index 000000000000..8123bbfe0279 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/DateTimeLiteralExpressionImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `DateTimeLiteralExpression`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.DateTimeLiteralExpression + +/** + * INTERNAL: This module contains the customizable definition of `DateTimeLiteralExpression` and should not + * be referenced directly. + */ +module Impl { + class DateTimeLiteralExpression extends Generated::DateTimeLiteralExpression { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/DateTimeTypeConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/DateTimeTypeConstructor.qll new file mode 100644 index 000000000000..7891b89f1bc9 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/DateTimeTypeConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `DateTimeType` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `DateTimeType` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructDateTimeType(Raw::DateTimeType id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/DateTimeTypeImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/DateTimeTypeImpl.qll new file mode 100644 index 000000000000..2eec57da5c63 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/DateTimeTypeImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `DateTimeType`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.DateTimeType + +/** + * INTERNAL: This module contains the customizable definition of `DateTimeType` and should not + * be referenced directly. + */ +module Impl { + class DateTimeType extends Generated::DateTimeType { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/DateTypeConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/DateTypeConstructor.qll new file mode 100644 index 000000000000..cebb3f9e4ce1 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/DateTypeConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `DateType` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `DateType` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructDateType(Raw::DateType id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/DateTypeImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/DateTypeImpl.qll new file mode 100644 index 000000000000..cf25bb7c5233 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/DateTypeImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `DateType`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.DateType + +/** + * INTERNAL: This module contains the customizable definition of `DateType` and should not + * be referenced directly. + */ +module Impl { + class DateType extends Generated::DateType { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/DblAttributeLiteralConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/DblAttributeLiteralConstructor.qll new file mode 100644 index 000000000000..f01819f1e04e --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/DblAttributeLiteralConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `DblAttributeLiteral` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `DblAttributeLiteral` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructDblAttributeLiteral(Raw::DblAttributeLiteral id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/DblAttributeLiteralImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/DblAttributeLiteralImpl.qll new file mode 100644 index 000000000000..6e8be134612c --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/DblAttributeLiteralImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `DblAttributeLiteral`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.DblAttributeLiteral + +/** + * INTERNAL: This module contains the customizable definition of `DblAttributeLiteral` and should not + * be referenced directly. + */ +module Impl { + class DblAttributeLiteral extends Generated::DblAttributeLiteral { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/DblTypeConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/DblTypeConstructor.qll new file mode 100644 index 000000000000..556a168ac9ad --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/DblTypeConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `DblType` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `DblType` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructDblType(Raw::DblType id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/DblTypeImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/DblTypeImpl.qll new file mode 100644 index 000000000000..3f388e78247e --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/DblTypeImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `DblType`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.DblType + +/** + * INTERNAL: This module contains the customizable definition of `DblType` and should not + * be referenced directly. + */ +module Impl { + class DblType extends Generated::DblType { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/DeclarationImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/DeclarationImpl.qll new file mode 100644 index 000000000000..23f26d1298f3 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/DeclarationImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `Declaration`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Declaration + +/** + * INTERNAL: This module contains the customizable definition of `Declaration` and should not + * be referenced directly. + */ +module Impl { + class Declaration extends Generated::Declaration { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/DefaultTypeAttributeLiteralImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/DefaultTypeAttributeLiteralImpl.qll new file mode 100644 index 000000000000..9f73fe962743 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/DefaultTypeAttributeLiteralImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `DefaultTypeAttributeLiteral`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.DefaultTypeAttributeLiteral + +/** + * INTERNAL: This module contains the customizable definition of `DefaultTypeAttributeLiteral` and should not + * be referenced directly. + */ +module Impl { + class DefaultTypeAttributeLiteral extends Generated::DefaultTypeAttributeLiteral { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/DefaultTypeLiteralExpressionImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/DefaultTypeLiteralExpressionImpl.qll new file mode 100644 index 000000000000..2babc9b16a4f --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/DefaultTypeLiteralExpressionImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `DefaultTypeLiteralExpression`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.DefaultTypeLiteralExpression + +/** + * INTERNAL: This module contains the customizable definition of `DefaultTypeLiteralExpression` and should not + * be referenced directly. + */ +module Impl { + class DefaultTypeLiteralExpression extends Generated::DefaultTypeLiteralExpression { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/DelegateConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/DelegateConstructor.qll new file mode 100644 index 000000000000..8862a6375c3c --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/DelegateConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `Delegate` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `Delegate` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructDelegate(Raw::Delegate id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/DelegateImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/DelegateImpl.qll new file mode 100644 index 000000000000..ae855649467d --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/DelegateImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `Delegate`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Delegate + +/** + * INTERNAL: This module contains the customizable definition of `Delegate` and should not + * be referenced directly. + */ +module Impl { + class Delegate extends Generated::Delegate { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/DeleteStatementConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/DeleteStatementConstructor.qll new file mode 100644 index 000000000000..efe89bfbefb8 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/DeleteStatementConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `DeleteStatement` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `DeleteStatement` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructDeleteStatement(Raw::DeleteStatement id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/DeleteStatementImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/DeleteStatementImpl.qll new file mode 100644 index 000000000000..78179e68724d --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/DeleteStatementImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `DeleteStatement`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.DeleteStatement + +/** + * INTERNAL: This module contains the customizable definition of `DeleteStatement` and should not + * be referenced directly. + */ +module Impl { + class DeleteStatement extends Generated::DeleteStatement { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/DivideExpressionConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/DivideExpressionConstructor.qll new file mode 100644 index 000000000000..39320ebced25 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/DivideExpressionConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `DivideExpression` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `DivideExpression` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructDivideExpression(Raw::DivideExpression id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/DivideExpressionImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/DivideExpressionImpl.qll new file mode 100644 index 000000000000..1315ebb44bd9 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/DivideExpressionImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `DivideExpression`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.DivideExpression + +/** + * INTERNAL: This module contains the customizable definition of `DivideExpression` and should not + * be referenced directly. + */ +module Impl { + class DivideExpression extends Generated::DivideExpression { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/DoWhileStatementConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/DoWhileStatementConstructor.qll new file mode 100644 index 000000000000..b7faa60d059b --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/DoWhileStatementConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `DoWhileStatement` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `DoWhileStatement` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructDoWhileStatement(Raw::DoWhileStatement id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/DoWhileStatementImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/DoWhileStatementImpl.qll new file mode 100644 index 000000000000..257b591141e6 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/DoWhileStatementImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `DoWhileStatement`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.DoWhileStatement + +/** + * INTERNAL: This module contains the customizable definition of `DoWhileStatement` and should not + * be referenced directly. + */ +module Impl { + class DoWhileStatement extends Generated::DoWhileStatement { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/ElementImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/ElementImpl.qll new file mode 100644 index 000000000000..63902837be32 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/ElementImpl.qll @@ -0,0 +1,21 @@ +/** + * This module provides a hand-modifiable wrapper around the generated class `Element`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Element + +/** + * INTERNAL: This module contains the customizable definition of `Element` and should not + * be referenced directly. + */ +module Impl { + class Element extends Generated::Element { + /** + * Elements print as their most specific QL class by default. Subclasses carrying a useful + * name or value override this in their own `...Impl.qll`. + */ + override string toStringImpl() { result = this.getAPrimaryQlClass() } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/EmptyExpressionConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/EmptyExpressionConstructor.qll new file mode 100644 index 000000000000..9e616b4bc336 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/EmptyExpressionConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `EmptyExpression` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `EmptyExpression` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructEmptyExpression(Raw::EmptyExpression id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/EmptyExpressionImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/EmptyExpressionImpl.qll new file mode 100644 index 000000000000..6c3811b5fff8 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/EmptyExpressionImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `EmptyExpression`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.EmptyExpression + +/** + * INTERNAL: This module contains the customizable definition of `EmptyExpression` and should not + * be referenced directly. + */ +module Impl { + class EmptyExpression extends Generated::EmptyExpression { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/EmptyStatementConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/EmptyStatementConstructor.qll new file mode 100644 index 000000000000..bae23e48d403 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/EmptyStatementConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `EmptyStatement` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `EmptyStatement` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructEmptyStatement(Raw::EmptyStatement id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/EmptyStatementImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/EmptyStatementImpl.qll new file mode 100644 index 000000000000..b307bfe5d46b --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/EmptyStatementImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `EmptyStatement`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.EmptyStatement + +/** + * INTERNAL: This module contains the customizable definition of `EmptyStatement` and should not + * be referenced directly. + */ +module Impl { + class EmptyStatement extends Generated::EmptyStatement { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/EnumAttributeLiteralConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/EnumAttributeLiteralConstructor.qll new file mode 100644 index 000000000000..1d143da45cbd --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/EnumAttributeLiteralConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `EnumAttributeLiteral` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `EnumAttributeLiteral` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructEnumAttributeLiteral(Raw::EnumAttributeLiteral id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/EnumAttributeLiteralImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/EnumAttributeLiteralImpl.qll new file mode 100644 index 000000000000..d372d803d940 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/EnumAttributeLiteralImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `EnumAttributeLiteral`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.EnumAttributeLiteral + +/** + * INTERNAL: This module contains the customizable definition of `EnumAttributeLiteral` and should not + * be referenced directly. + */ +module Impl { + class EnumAttributeLiteral extends Generated::EnumAttributeLiteral { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/EnumerationLiteralExpressionConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/EnumerationLiteralExpressionConstructor.qll new file mode 100644 index 000000000000..1adee5bc6b21 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/EnumerationLiteralExpressionConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `EnumerationLiteralExpression` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `EnumerationLiteralExpression` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructEnumerationLiteralExpression(Raw::EnumerationLiteralExpression id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/EnumerationLiteralExpressionImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/EnumerationLiteralExpressionImpl.qll new file mode 100644 index 000000000000..33d517dc3d83 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/EnumerationLiteralExpressionImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `EnumerationLiteralExpression`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.EnumerationLiteralExpression + +/** + * INTERNAL: This module contains the customizable definition of `EnumerationLiteralExpression` and should not + * be referenced directly. + */ +module Impl { + class EnumerationLiteralExpression extends Generated::EnumerationLiteralExpression { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/EnumerationTypeConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/EnumerationTypeConstructor.qll new file mode 100644 index 000000000000..c81c84f37d6f --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/EnumerationTypeConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `EnumerationType` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `EnumerationType` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructEnumerationType(Raw::EnumerationType id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/EnumerationTypeImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/EnumerationTypeImpl.qll new file mode 100644 index 000000000000..b8f069517074 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/EnumerationTypeImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `EnumerationType`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.EnumerationType + +/** + * INTERNAL: This module contains the customizable definition of `EnumerationType` and should not + * be referenced directly. + */ +module Impl { + class EnumerationType extends Generated::EnumerationType { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/EqualExpressionConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/EqualExpressionConstructor.qll new file mode 100644 index 000000000000..5e7228933722 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/EqualExpressionConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `EqualExpression` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `EqualExpression` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructEqualExpression(Raw::EqualExpression id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/EqualExpressionImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/EqualExpressionImpl.qll new file mode 100644 index 000000000000..30f53789f0ee --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/EqualExpressionImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `EqualExpression`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.EqualExpression + +/** + * INTERNAL: This module contains the customizable definition of `EqualExpression` and should not + * be referenced directly. + */ +module Impl { + class EqualExpression extends Generated::EqualExpression { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/ErrorElementImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/ErrorElementImpl.qll new file mode 100644 index 000000000000..7b67e940021f --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/ErrorElementImpl.qll @@ -0,0 +1,19 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `ErrorElement`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.ErrorElement + +/** + * INTERNAL: This module contains the customizable definition of `ErrorElement` and should not + * be referenced directly. + */ +module Impl { + /** + * The superclass of all elements indicating some kind of error. + */ + class ErrorElement extends Generated::ErrorElement { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/EvaluationActualParameterEntryConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/EvaluationActualParameterEntryConstructor.qll new file mode 100644 index 000000000000..245b59e551e0 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/EvaluationActualParameterEntryConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `EvaluationActualParameterEntry` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `EvaluationActualParameterEntry` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructEvaluationActualParameterEntry(Raw::EvaluationActualParameterEntry id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/EvaluationActualParameterEntryImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/EvaluationActualParameterEntryImpl.qll new file mode 100644 index 000000000000..1ac2bbe73b6c --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/EvaluationActualParameterEntryImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `EvaluationActualParameterEntry`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.EvaluationActualParameterEntry + +/** + * INTERNAL: This module contains the customizable definition of `EvaluationActualParameterEntry` and should not + * be referenced directly. + */ +module Impl { + class EvaluationActualParameterEntry extends Generated::EvaluationActualParameterEntry { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/EvaluationImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/EvaluationImpl.qll new file mode 100644 index 000000000000..c9c5152788d8 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/EvaluationImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `Evaluation`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Evaluation + +/** + * INTERNAL: This module contains the customizable definition of `Evaluation` and should not + * be referenced directly. + */ +module Impl { + class Evaluation extends Generated::Evaluation { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/ExplicitSelectionConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/ExplicitSelectionConstructor.qll new file mode 100644 index 000000000000..8abb3d3c4a82 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/ExplicitSelectionConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `ExplicitSelection` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `ExplicitSelection` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructExplicitSelection(Raw::ExplicitSelection id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/ExplicitSelectionImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/ExplicitSelectionImpl.qll new file mode 100644 index 000000000000..8f4f1239b2bf --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/ExplicitSelectionImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `ExplicitSelection`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.ExplicitSelection + +/** + * INTERNAL: This module contains the customizable definition of `ExplicitSelection` and should not + * be referenced directly. + */ +module Impl { + class ExplicitSelection extends Generated::ExplicitSelection { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/ExpressionCompilationUnitConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/ExpressionCompilationUnitConstructor.qll new file mode 100644 index 000000000000..3bb7a30e9494 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/ExpressionCompilationUnitConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `ExpressionCompilationUnit` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `ExpressionCompilationUnit` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructExpressionCompilationUnit(Raw::ExpressionCompilationUnit id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/ExpressionCompilationUnitImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/ExpressionCompilationUnitImpl.qll new file mode 100644 index 000000000000..145758d147bc --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/ExpressionCompilationUnitImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `ExpressionCompilationUnit`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.ExpressionCompilationUnit + +/** + * INTERNAL: This module contains the customizable definition of `ExpressionCompilationUnit` and should not + * be referenced directly. + */ +module Impl { + class ExpressionCompilationUnit extends Generated::ExpressionCompilationUnit { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/ExpressionImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/ExpressionImpl.qll new file mode 100644 index 000000000000..66e86b8c70ae --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/ExpressionImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `Expression`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Expression + +/** + * INTERNAL: This module contains the customizable definition of `Expression` and should not + * be referenced directly. + */ +module Impl { + class Expression extends Generated::Expression { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/ExpressionQualifierConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/ExpressionQualifierConstructor.qll new file mode 100644 index 000000000000..22871f13eb98 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/ExpressionQualifierConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `ExpressionQualifier` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `ExpressionQualifier` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructExpressionQualifier(Raw::ExpressionQualifier id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/ExpressionQualifierImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/ExpressionQualifierImpl.qll new file mode 100644 index 000000000000..11d6d0a5c464 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/ExpressionQualifierImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `ExpressionQualifier`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.ExpressionQualifier + +/** + * INTERNAL: This module contains the customizable definition of `ExpressionQualifier` and should not + * be referenced directly. + */ +module Impl { + class ExpressionQualifier extends Generated::ExpressionQualifier { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/ExpressionStatementConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/ExpressionStatementConstructor.qll new file mode 100644 index 000000000000..281cca287309 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/ExpressionStatementConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `ExpressionStatement` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `ExpressionStatement` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructExpressionStatement(Raw::ExpressionStatement id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/ExpressionStatementImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/ExpressionStatementImpl.qll new file mode 100644 index 000000000000..10d483b46cf6 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/ExpressionStatementImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `ExpressionStatement`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.ExpressionStatement + +/** + * INTERNAL: This module contains the customizable definition of `ExpressionStatement` and should not + * be referenced directly. + */ +module Impl { + class ExpressionStatement extends Generated::ExpressionStatement { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/FieldAssignmentConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/FieldAssignmentConstructor.qll new file mode 100644 index 000000000000..a2fa7ae6d5f7 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/FieldAssignmentConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `FieldAssignment` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `FieldAssignment` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructFieldAssignment(Raw::FieldAssignment id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/FieldAssignmentImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/FieldAssignmentImpl.qll new file mode 100644 index 000000000000..9bf0dd59c57a --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/FieldAssignmentImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `FieldAssignment`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.FieldAssignment + +/** + * INTERNAL: This module contains the customizable definition of `FieldAssignment` and should not + * be referenced directly. + */ +module Impl { + class FieldAssignment extends Generated::FieldAssignment { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/FieldDeclarationImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/FieldDeclarationImpl.qll new file mode 100644 index 000000000000..01b8f338f207 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/FieldDeclarationImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `FieldDeclaration`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.FieldDeclaration + +/** + * INTERNAL: This module contains the customizable definition of `FieldDeclaration` and should not + * be referenced directly. + */ +module Impl { + class FieldDeclaration extends Generated::FieldDeclaration { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/FieldDeclarationInternalConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/FieldDeclarationInternalConstructor.qll new file mode 100644 index 000000000000..ff30a9d0c87e --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/FieldDeclarationInternalConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `FieldDeclarationInternal` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `FieldDeclarationInternal` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructFieldDeclarationInternal(Raw::FieldDeclarationInternal id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/FieldDeclarationInternalImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/FieldDeclarationInternalImpl.qll new file mode 100644 index 000000000000..345169f777a2 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/FieldDeclarationInternalImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `FieldDeclarationInternal`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.FieldDeclarationInternal + +/** + * INTERNAL: This module contains the customizable definition of `FieldDeclarationInternal` and should not + * be referenced directly. + */ +module Impl { + class FieldDeclarationInternal extends Generated::FieldDeclarationInternal { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/FieldExpressionImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/FieldExpressionImpl.qll new file mode 100644 index 000000000000..9abbbd783dab --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/FieldExpressionImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `FieldExpression`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.FieldExpression + +/** + * INTERNAL: This module contains the customizable definition of `FieldExpression` and should not + * be referenced directly. + */ +module Impl { + class FieldExpression extends Generated::FieldExpression { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/FieldExpressionInternalConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/FieldExpressionInternalConstructor.qll new file mode 100644 index 000000000000..810de0cfe0de --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/FieldExpressionInternalConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `FieldExpressionInternal` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `FieldExpressionInternal` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructFieldExpressionInternal(Raw::FieldExpressionInternal id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/FieldExpressionInternalImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/FieldExpressionInternalImpl.qll new file mode 100644 index 000000000000..cc67f00eea23 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/FieldExpressionInternalImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `FieldExpressionInternal`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.FieldExpressionInternal + +/** + * INTERNAL: This module contains the customizable definition of `FieldExpressionInternal` and should not + * be referenced directly. + */ +module Impl { + class FieldExpressionInternal extends Generated::FieldExpressionInternal { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/FieldSelectionConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/FieldSelectionConstructor.qll new file mode 100644 index 000000000000..339a62b4f4d5 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/FieldSelectionConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `FieldSelection` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `FieldSelection` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructFieldSelection(Raw::FieldSelection id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/FieldSelectionImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/FieldSelectionImpl.qll new file mode 100644 index 000000000000..c1cfa8aab7c9 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/FieldSelectionImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `FieldSelection`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.FieldSelection + +/** + * INTERNAL: This module contains the customizable definition of `FieldSelection` and should not + * be referenced directly. + */ +module Impl { + class FieldSelection extends Generated::FieldSelection { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/FieldSpecificationImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/FieldSpecificationImpl.qll new file mode 100644 index 000000000000..116269bed5de --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/FieldSpecificationImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `FieldSpecification`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.FieldSpecification + +/** + * INTERNAL: This module contains the customizable definition of `FieldSpecification` and should not + * be referenced directly. + */ +module Impl { + class FieldSpecification extends Generated::FieldSpecification { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/FileConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/FileConstructor.qll new file mode 100644 index 000000000000..f57110c53a58 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/FileConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `File` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `File` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructFile(Raw::File id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/FileImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/FileImpl.qll new file mode 100644 index 000000000000..4eaf8e3ef27e --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/FileImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `File`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.File + +/** + * INTERNAL: This module contains the customizable definition of `File` and should not + * be referenced directly. + */ +module Impl { + class File extends Generated::File { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/FindStatementConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/FindStatementConstructor.qll new file mode 100644 index 000000000000..efd065bd387c --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/FindStatementConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `FindStatement` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `FindStatement` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructFindStatement(Raw::FindStatement id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/FindStatementImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/FindStatementImpl.qll new file mode 100644 index 000000000000..f3cc10d8e8c1 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/FindStatementImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `FindStatement`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.FindStatement + +/** + * INTERNAL: This module contains the customizable definition of `FindStatement` and should not + * be referenced directly. + */ +module Impl { + class FindStatement extends Generated::FindStatement { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/FlushStatementConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/FlushStatementConstructor.qll new file mode 100644 index 000000000000..334b125ff00b --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/FlushStatementConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `FlushStatement` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `FlushStatement` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructFlushStatement(Raw::FlushStatement id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/FlushStatementImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/FlushStatementImpl.qll new file mode 100644 index 000000000000..c1051cfc8c97 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/FlushStatementImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `FlushStatement`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.FlushStatement + +/** + * INTERNAL: This module contains the customizable definition of `FlushStatement` and should not + * be referenced directly. + */ +module Impl { + class FlushStatement extends Generated::FlushStatement { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/ForAssignImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/ForAssignImpl.qll new file mode 100644 index 000000000000..4a9751cd0bf5 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/ForAssignImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `ForAssign`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.ForAssign + +/** + * INTERNAL: This module contains the customizable definition of `ForAssign` and should not + * be referenced directly. + */ +module Impl { + class ForAssign extends Generated::ForAssign { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/ForDeclarationAssignConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/ForDeclarationAssignConstructor.qll new file mode 100644 index 000000000000..d59e3fe17b15 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/ForDeclarationAssignConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `ForDeclarationAssign` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `ForDeclarationAssign` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructForDeclarationAssign(Raw::ForDeclarationAssign id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/ForDeclarationAssignImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/ForDeclarationAssignImpl.qll new file mode 100644 index 000000000000..a7bb29536576 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/ForDeclarationAssignImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `ForDeclarationAssign`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.ForDeclarationAssign + +/** + * INTERNAL: This module contains the customizable definition of `ForDeclarationAssign` and should not + * be referenced directly. + */ +module Impl { + class ForDeclarationAssign extends Generated::ForDeclarationAssign { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/ForExpressionAssignImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/ForExpressionAssignImpl.qll new file mode 100644 index 000000000000..9237746f82bc --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/ForExpressionAssignImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `ForExpressionAssign`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.ForExpressionAssign + +/** + * INTERNAL: This module contains the customizable definition of `ForExpressionAssign` and should not + * be referenced directly. + */ +module Impl { + class ForExpressionAssign extends Generated::ForExpressionAssign { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/ForFieldAssignConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/ForFieldAssignConstructor.qll new file mode 100644 index 000000000000..ae19b8d4ff7c --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/ForFieldAssignConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `ForFieldAssign` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `ForFieldAssign` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructForFieldAssign(Raw::ForFieldAssign id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/ForFieldAssignImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/ForFieldAssignImpl.qll new file mode 100644 index 000000000000..0a7d9f10a278 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/ForFieldAssignImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `ForFieldAssign`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.ForFieldAssign + +/** + * INTERNAL: This module contains the customizable definition of `ForFieldAssign` and should not + * be referenced directly. + */ +module Impl { + class ForFieldAssign extends Generated::ForFieldAssign { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/ForFieldDecrementAssignConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/ForFieldDecrementAssignConstructor.qll new file mode 100644 index 000000000000..ce716432b5aa --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/ForFieldDecrementAssignConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `ForFieldDecrementAssign` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `ForFieldDecrementAssign` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructForFieldDecrementAssign(Raw::ForFieldDecrementAssign id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/ForFieldDecrementAssignImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/ForFieldDecrementAssignImpl.qll new file mode 100644 index 000000000000..dbb2f6ff35e7 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/ForFieldDecrementAssignImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `ForFieldDecrementAssign`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.ForFieldDecrementAssign + +/** + * INTERNAL: This module contains the customizable definition of `ForFieldDecrementAssign` and should not + * be referenced directly. + */ +module Impl { + class ForFieldDecrementAssign extends Generated::ForFieldDecrementAssign { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/ForFieldIncrementAssignConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/ForFieldIncrementAssignConstructor.qll new file mode 100644 index 000000000000..64eb49c6fafd --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/ForFieldIncrementAssignConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `ForFieldIncrementAssign` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `ForFieldIncrementAssign` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructForFieldIncrementAssign(Raw::ForFieldIncrementAssign id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/ForFieldIncrementAssignImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/ForFieldIncrementAssignImpl.qll new file mode 100644 index 000000000000..c951659edc2c --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/ForFieldIncrementAssignImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `ForFieldIncrementAssign`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.ForFieldIncrementAssign + +/** + * INTERNAL: This module contains the customizable definition of `ForFieldIncrementAssign` and should not + * be referenced directly. + */ +module Impl { + class ForFieldIncrementAssign extends Generated::ForFieldIncrementAssign { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/ForFieldPostDecrementConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/ForFieldPostDecrementConstructor.qll new file mode 100644 index 000000000000..9603feef548c --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/ForFieldPostDecrementConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `ForFieldPostDecrement` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `ForFieldPostDecrement` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructForFieldPostDecrement(Raw::ForFieldPostDecrement id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/ForFieldPostDecrementImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/ForFieldPostDecrementImpl.qll new file mode 100644 index 000000000000..0143bb3c5409 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/ForFieldPostDecrementImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `ForFieldPostDecrement`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.ForFieldPostDecrement + +/** + * INTERNAL: This module contains the customizable definition of `ForFieldPostDecrement` and should not + * be referenced directly. + */ +module Impl { + class ForFieldPostDecrement extends Generated::ForFieldPostDecrement { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/ForFieldPostIncrementConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/ForFieldPostIncrementConstructor.qll new file mode 100644 index 000000000000..52ecad120d1d --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/ForFieldPostIncrementConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `ForFieldPostIncrement` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `ForFieldPostIncrement` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructForFieldPostIncrement(Raw::ForFieldPostIncrement id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/ForFieldPostIncrementImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/ForFieldPostIncrementImpl.qll new file mode 100644 index 000000000000..1d67117dc4bc --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/ForFieldPostIncrementImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `ForFieldPostIncrement`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.ForFieldPostIncrement + +/** + * INTERNAL: This module contains the customizable definition of `ForFieldPostIncrement` and should not + * be referenced directly. + */ +module Impl { + class ForFieldPostIncrement extends Generated::ForFieldPostIncrement { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/ForFieldPreDecrementConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/ForFieldPreDecrementConstructor.qll new file mode 100644 index 000000000000..4532117d0fda --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/ForFieldPreDecrementConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `ForFieldPreDecrement` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `ForFieldPreDecrement` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructForFieldPreDecrement(Raw::ForFieldPreDecrement id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/ForFieldPreDecrementImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/ForFieldPreDecrementImpl.qll new file mode 100644 index 000000000000..9b8eed11541c --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/ForFieldPreDecrementImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `ForFieldPreDecrement`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.ForFieldPreDecrement + +/** + * INTERNAL: This module contains the customizable definition of `ForFieldPreDecrement` and should not + * be referenced directly. + */ +module Impl { + class ForFieldPreDecrement extends Generated::ForFieldPreDecrement { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/ForFieldPreIncrementConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/ForFieldPreIncrementConstructor.qll new file mode 100644 index 000000000000..27837af621de --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/ForFieldPreIncrementConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `ForFieldPreIncrement` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `ForFieldPreIncrement` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructForFieldPreIncrement(Raw::ForFieldPreIncrement id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/ForFieldPreIncrementImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/ForFieldPreIncrementImpl.qll new file mode 100644 index 000000000000..56c2bfbd8b79 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/ForFieldPreIncrementImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `ForFieldPreIncrement`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.ForFieldPreIncrement + +/** + * INTERNAL: This module contains the customizable definition of `ForFieldPreIncrement` and should not + * be referenced directly. + */ +module Impl { + class ForFieldPreIncrement extends Generated::ForFieldPreIncrement { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/ForStatementConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/ForStatementConstructor.qll new file mode 100644 index 000000000000..185379a331b4 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/ForStatementConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `ForStatement` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `ForStatement` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructForStatement(Raw::ForStatement id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/ForStatementImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/ForStatementImpl.qll new file mode 100644 index 000000000000..16fff001a1f8 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/ForStatementImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `ForStatement`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.ForStatement + +/** + * INTERNAL: This module contains the customizable definition of `ForStatement` and should not + * be referenced directly. + */ +module Impl { + class ForStatement extends Generated::ForStatement { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/FormControlConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/FormControlConstructor.qll new file mode 100644 index 000000000000..e768c9a4654c --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/FormControlConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `FormControl` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `FormControl` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructFormControl(Raw::FormControl id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/FormControlImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/FormControlImpl.qll new file mode 100644 index 000000000000..86fa4680858d --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/FormControlImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `FormControl`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.FormControl + +/** + * INTERNAL: This module contains the customizable definition of `FormControl` and should not + * be referenced directly. + */ +module Impl { + class FormControl extends Generated::FormControl { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/FormDataFieldConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/FormDataFieldConstructor.qll new file mode 100644 index 000000000000..d1483224256d --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/FormDataFieldConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `FormDataField` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `FormDataField` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructFormDataField(Raw::FormDataField id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/FormDataFieldImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/FormDataFieldImpl.qll new file mode 100644 index 000000000000..740cf8b9a00b --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/FormDataFieldImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `FormDataField`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.FormDataField + +/** + * INTERNAL: This module contains the customizable definition of `FormDataField` and should not + * be referenced directly. + */ +module Impl { + class FormDataField extends Generated::FormDataField { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/FormDataSourceConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/FormDataSourceConstructor.qll new file mode 100644 index 000000000000..382f4f9ae59e --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/FormDataSourceConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `FormDataSource` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `FormDataSource` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructFormDataSource(Raw::FormDataSource id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/FormDataSourceImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/FormDataSourceImpl.qll new file mode 100644 index 000000000000..67456b5abd85 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/FormDataSourceImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `FormDataSource`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.FormDataSource + +/** + * INTERNAL: This module contains the customizable definition of `FormDataSource` and should not + * be referenced directly. + */ +module Impl { + class FormDataSource extends Generated::FormDataSource { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/FormElementTypeConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/FormElementTypeConstructor.qll new file mode 100644 index 000000000000..5813d3efc8db --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/FormElementTypeConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `FormElementType` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `FormElementType` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructFormElementType(Raw::FormElementType id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/FormElementTypeImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/FormElementTypeImpl.qll new file mode 100644 index 000000000000..751b03bf88ff --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/FormElementTypeImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `FormElementType`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.FormElementType + +/** + * INTERNAL: This module contains the customizable definition of `FormElementType` and should not + * be referenced directly. + */ +module Impl { + class FormElementType extends Generated::FormElementType { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/FormModelElementConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/FormModelElementConstructor.qll new file mode 100644 index 000000000000..13cb81859251 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/FormModelElementConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `FormModelElement` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `FormModelElement` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructFormModelElement(Raw::FormModelElement id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/FormModelElementImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/FormModelElementImpl.qll new file mode 100644 index 000000000000..7a2813419342 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/FormModelElementImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `FormModelElement`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.FormModelElement + +/** + * INTERNAL: This module contains the customizable definition of `FormModelElement` and should not + * be referenced directly. + */ +module Impl { + class FormModelElement extends Generated::FormModelElement { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/FormNestedElementImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/FormNestedElementImpl.qll new file mode 100644 index 000000000000..ea77904d5e1b --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/FormNestedElementImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `FormNestedElement`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.FormNestedElement + +/** + * INTERNAL: This module contains the customizable definition of `FormNestedElement` and should not + * be referenced directly. + */ +module Impl { + class FormNestedElement extends Generated::FormNestedElement { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/FunctionCallConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/FunctionCallConstructor.qll new file mode 100644 index 000000000000..cb203f810a74 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/FunctionCallConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `FunctionCall` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `FunctionCall` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructFunctionCall(Raw::FunctionCall id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/FunctionCallImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/FunctionCallImpl.qll new file mode 100644 index 000000000000..2ef8102df773 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/FunctionCallImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `FunctionCall`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.FunctionCall + +/** + * INTERNAL: This module contains the customizable definition of `FunctionCall` and should not + * be referenced directly. + */ +module Impl { + class FunctionCall extends Generated::FunctionCall { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/FunctionDeclarationConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/FunctionDeclarationConstructor.qll new file mode 100644 index 000000000000..8764136a43ea --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/FunctionDeclarationConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `FunctionDeclaration` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `FunctionDeclaration` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructFunctionDeclaration(Raw::FunctionDeclaration id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/FunctionDeclarationImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/FunctionDeclarationImpl.qll new file mode 100644 index 000000000000..1eb94d741b78 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/FunctionDeclarationImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `FunctionDeclaration`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.FunctionDeclaration + +/** + * INTERNAL: This module contains the customizable definition of `FunctionDeclaration` and should not + * be referenced directly. + */ +module Impl { + class FunctionDeclaration extends Generated::FunctionDeclaration { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/GenericEvaluationImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/GenericEvaluationImpl.qll new file mode 100644 index 000000000000..31a476564761 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/GenericEvaluationImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `GenericEvaluation`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.GenericEvaluation + +/** + * INTERNAL: This module contains the customizable definition of `GenericEvaluation` and should not + * be referenced directly. + */ +module Impl { + class GenericEvaluation extends Generated::GenericEvaluation { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/GenericXppTypeImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/GenericXppTypeImpl.qll new file mode 100644 index 000000000000..8c7b9471021f --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/GenericXppTypeImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `GenericXppType`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.GenericXppType + +/** + * INTERNAL: This module contains the customizable definition of `GenericXppType` and should not + * be referenced directly. + */ +module Impl { + class GenericXppType extends Generated::GenericXppType { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/GlobalOrderElementConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/GlobalOrderElementConstructor.qll new file mode 100644 index 000000000000..a6deb59ef41a --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/GlobalOrderElementConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `GlobalOrderElement` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `GlobalOrderElement` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructGlobalOrderElement(Raw::GlobalOrderElement id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/GlobalOrderElementImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/GlobalOrderElementImpl.qll new file mode 100644 index 000000000000..ab7062443f91 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/GlobalOrderElementImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `GlobalOrderElement`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.GlobalOrderElement + +/** + * INTERNAL: This module contains the customizable definition of `GlobalOrderElement` and should not + * be referenced directly. + */ +module Impl { + class GlobalOrderElement extends Generated::GlobalOrderElement { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/GreaterThanExpressionConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/GreaterThanExpressionConstructor.qll new file mode 100644 index 000000000000..6bbc7bb92bdc --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/GreaterThanExpressionConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `GreaterThanExpression` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `GreaterThanExpression` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructGreaterThanExpression(Raw::GreaterThanExpression id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/GreaterThanExpressionImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/GreaterThanExpressionImpl.qll new file mode 100644 index 000000000000..fa387cb15af6 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/GreaterThanExpressionImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `GreaterThanExpression`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.GreaterThanExpression + +/** + * INTERNAL: This module contains the customizable definition of `GreaterThanExpression` and should not + * be referenced directly. + */ +module Impl { + class GreaterThanExpression extends Generated::GreaterThanExpression { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/GreaterThanOrEqualExpressionConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/GreaterThanOrEqualExpressionConstructor.qll new file mode 100644 index 000000000000..29bdae9141b3 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/GreaterThanOrEqualExpressionConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `GreaterThanOrEqualExpression` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `GreaterThanOrEqualExpression` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructGreaterThanOrEqualExpression(Raw::GreaterThanOrEqualExpression id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/GreaterThanOrEqualExpressionImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/GreaterThanOrEqualExpressionImpl.qll new file mode 100644 index 000000000000..f381bde90e77 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/GreaterThanOrEqualExpressionImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `GreaterThanOrEqualExpression`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.GreaterThanOrEqualExpression + +/** + * INTERNAL: This module contains the customizable definition of `GreaterThanOrEqualExpression` and should not + * be referenced directly. + */ +module Impl { + class GreaterThanOrEqualExpression extends Generated::GreaterThanOrEqualExpression { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/GuidAttributeLiteralConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/GuidAttributeLiteralConstructor.qll new file mode 100644 index 000000000000..ff6a153a1e90 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/GuidAttributeLiteralConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `GuidAttributeLiteral` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `GuidAttributeLiteral` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructGuidAttributeLiteral(Raw::GuidAttributeLiteral id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/GuidAttributeLiteralImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/GuidAttributeLiteralImpl.qll new file mode 100644 index 000000000000..a29a5b3fd111 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/GuidAttributeLiteralImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `GuidAttributeLiteral`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.GuidAttributeLiteral + +/** + * INTERNAL: This module contains the customizable definition of `GuidAttributeLiteral` and should not + * be referenced directly. + */ +module Impl { + class GuidAttributeLiteral extends Generated::GuidAttributeLiteral { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/GuidTypeConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/GuidTypeConstructor.qll new file mode 100644 index 000000000000..da88702abb52 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/GuidTypeConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `GuidType` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `GuidType` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructGuidType(Raw::GuidType id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/GuidTypeImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/GuidTypeImpl.qll new file mode 100644 index 000000000000..f6111c1b34ee --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/GuidTypeImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `GuidType`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.GuidType + +/** + * INTERNAL: This module contains the customizable definition of `GuidType` and should not + * be referenced directly. + */ +module Impl { + class GuidType extends Generated::GuidType { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/IfStatementConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/IfStatementConstructor.qll new file mode 100644 index 000000000000..1b7751509848 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/IfStatementConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `IfStatement` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `IfStatement` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructIfStatement(Raw::IfStatement id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/IfStatementImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/IfStatementImpl.qll new file mode 100644 index 000000000000..b3321488b6a1 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/IfStatementImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `IfStatement`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.IfStatement + +/** + * INTERNAL: This module contains the customizable definition of `IfStatement` and should not + * be referenced directly. + */ +module Impl { + class IfStatement extends Generated::IfStatement { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/IfThenElseStatementConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/IfThenElseStatementConstructor.qll new file mode 100644 index 000000000000..ae3279cbd8dd --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/IfThenElseStatementConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `IfThenElseStatement` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `IfThenElseStatement` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructIfThenElseStatement(Raw::IfThenElseStatement id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/IfThenElseStatementImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/IfThenElseStatementImpl.qll new file mode 100644 index 000000000000..34b3530e9883 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/IfThenElseStatementImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `IfThenElseStatement`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.IfThenElseStatement + +/** + * INTERNAL: This module contains the customizable definition of `IfThenElseStatement` and should not + * be referenced directly. + */ +module Impl { + class IfThenElseStatement extends Generated::IfThenElseStatement { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/ImplicitSelectionConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/ImplicitSelectionConstructor.qll new file mode 100644 index 000000000000..f500c1fef24b --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/ImplicitSelectionConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `ImplicitSelection` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `ImplicitSelection` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructImplicitSelection(Raw::ImplicitSelection id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/ImplicitSelectionImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/ImplicitSelectionImpl.qll new file mode 100644 index 000000000000..18a184143cac --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/ImplicitSelectionImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `ImplicitSelection`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.ImplicitSelection + +/** + * INTERNAL: This module contains the customizable definition of `ImplicitSelection` and should not + * be referenced directly. + */ +module Impl { + class ImplicitSelection extends Generated::ImplicitSelection { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/InExpressionConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/InExpressionConstructor.qll new file mode 100644 index 000000000000..e964a71f6263 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/InExpressionConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `InExpression` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `InExpression` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructInExpression(Raw::InExpression id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/InExpressionImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/InExpressionImpl.qll new file mode 100644 index 000000000000..31aabec67726 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/InExpressionImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `InExpression`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.InExpression + +/** + * INTERNAL: This module contains the customizable definition of `InExpression` and should not + * be referenced directly. + */ +module Impl { + class InExpression extends Generated::InExpression { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/InsertFieldSpecificationConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/InsertFieldSpecificationConstructor.qll new file mode 100644 index 000000000000..a5a7c53bca92 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/InsertFieldSpecificationConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `InsertFieldSpecification` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `InsertFieldSpecification` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructInsertFieldSpecification(Raw::InsertFieldSpecification id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/InsertFieldSpecificationImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/InsertFieldSpecificationImpl.qll new file mode 100644 index 000000000000..4ea6314996c3 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/InsertFieldSpecificationImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `InsertFieldSpecification`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.InsertFieldSpecification + +/** + * INTERNAL: This module contains the customizable definition of `InsertFieldSpecification` and should not + * be referenced directly. + */ +module Impl { + class InsertFieldSpecification extends Generated::InsertFieldSpecification { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/InsertStatementConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/InsertStatementConstructor.qll new file mode 100644 index 000000000000..e3176cb7e752 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/InsertStatementConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `InsertStatement` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `InsertStatement` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructInsertStatement(Raw::InsertStatement id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/InsertStatementImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/InsertStatementImpl.qll new file mode 100644 index 000000000000..03f0983ec508 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/InsertStatementImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `InsertStatement`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.InsertStatement + +/** + * INTERNAL: This module contains the customizable definition of `InsertStatement` and should not + * be referenced directly. + */ +module Impl { + class InsertStatement extends Generated::InsertStatement { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/InstanceNameImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/InstanceNameImpl.qll new file mode 100644 index 000000000000..a39a92282240 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/InstanceNameImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `InstanceName`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.InstanceName + +/** + * INTERNAL: This module contains the customizable definition of `InstanceName` and should not + * be referenced directly. + */ +module Impl { + class InstanceName extends Generated::InstanceName { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/Int64AttributeLiteralConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/Int64AttributeLiteralConstructor.qll new file mode 100644 index 000000000000..268daf58fe1b --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/Int64AttributeLiteralConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `Int64AttributeLiteral` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `Int64AttributeLiteral` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructInt64AttributeLiteral(Raw::Int64AttributeLiteral id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/Int64AttributeLiteralImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/Int64AttributeLiteralImpl.qll new file mode 100644 index 000000000000..a3f45f68d41e --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/Int64AttributeLiteralImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `Int64AttributeLiteral`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Int64AttributeLiteral + +/** + * INTERNAL: This module contains the customizable definition of `Int64AttributeLiteral` and should not + * be referenced directly. + */ +module Impl { + class Int64AttributeLiteral extends Generated::Int64AttributeLiteral { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/Int64LiteralExpressionConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/Int64LiteralExpressionConstructor.qll new file mode 100644 index 000000000000..026c249d50fe --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/Int64LiteralExpressionConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `Int64LiteralExpression` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `Int64LiteralExpression` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructInt64LiteralExpression(Raw::Int64LiteralExpression id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/Int64LiteralExpressionImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/Int64LiteralExpressionImpl.qll new file mode 100644 index 000000000000..d50a1f0b8f43 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/Int64LiteralExpressionImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `Int64LiteralExpression`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Int64LiteralExpression + +/** + * INTERNAL: This module contains the customizable definition of `Int64LiteralExpression` and should not + * be referenced directly. + */ +module Impl { + class Int64LiteralExpression extends Generated::Int64LiteralExpression { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/Int64TypeConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/Int64TypeConstructor.qll new file mode 100644 index 000000000000..e694c64df811 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/Int64TypeConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `Int64Type` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `Int64Type` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructInt64Type(Raw::Int64Type id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/Int64TypeImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/Int64TypeImpl.qll new file mode 100644 index 000000000000..ee70a023dfe7 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/Int64TypeImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `Int64Type`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Int64Type + +/** + * INTERNAL: This module contains the customizable definition of `Int64Type` and should not + * be referenced directly. + */ +module Impl { + class Int64Type extends Generated::Int64Type { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/IntAttributeLiteralConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/IntAttributeLiteralConstructor.qll new file mode 100644 index 000000000000..b68c43f726e0 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/IntAttributeLiteralConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `IntAttributeLiteral` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `IntAttributeLiteral` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructIntAttributeLiteral(Raw::IntAttributeLiteral id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/IntAttributeLiteralImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/IntAttributeLiteralImpl.qll new file mode 100644 index 000000000000..49bf621e9396 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/IntAttributeLiteralImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `IntAttributeLiteral`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.IntAttributeLiteral + +/** + * INTERNAL: This module contains the customizable definition of `IntAttributeLiteral` and should not + * be referenced directly. + */ +module Impl { + class IntAttributeLiteral extends Generated::IntAttributeLiteral { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/IntLiteralExpressionConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/IntLiteralExpressionConstructor.qll new file mode 100644 index 000000000000..e20da8ada66a --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/IntLiteralExpressionConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `IntLiteralExpression` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `IntLiteralExpression` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructIntLiteralExpression(Raw::IntLiteralExpression id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/IntLiteralExpressionImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/IntLiteralExpressionImpl.qll new file mode 100644 index 000000000000..9082baea016b --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/IntLiteralExpressionImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `IntLiteralExpression`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.IntLiteralExpression + +/** + * INTERNAL: This module contains the customizable definition of `IntLiteralExpression` and should not + * be referenced directly. + */ +module Impl { + class IntLiteralExpression extends Generated::IntLiteralExpression { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/IntTypeConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/IntTypeConstructor.qll new file mode 100644 index 000000000000..8b9ab34c2c74 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/IntTypeConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `IntType` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `IntType` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructIntType(Raw::IntType id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/IntTypeImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/IntTypeImpl.qll new file mode 100644 index 000000000000..707200ae4524 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/IntTypeImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `IntType`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.IntType + +/** + * INTERNAL: This module contains the customizable definition of `IntType` and should not + * be referenced directly. + */ +module Impl { + class IntType extends Generated::IntType { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/IntegerDivideExpressionConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/IntegerDivideExpressionConstructor.qll new file mode 100644 index 000000000000..ce6b6be0b324 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/IntegerDivideExpressionConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `IntegerDivideExpression` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `IntegerDivideExpression` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructIntegerDivideExpression(Raw::IntegerDivideExpression id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/IntegerDivideExpressionImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/IntegerDivideExpressionImpl.qll new file mode 100644 index 000000000000..5103ceed63a5 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/IntegerDivideExpressionImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `IntegerDivideExpression`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.IntegerDivideExpression + +/** + * INTERNAL: This module contains the customizable definition of `IntegerDivideExpression` and should not + * be referenced directly. + */ +module Impl { + class IntegerDivideExpression extends Generated::IntegerDivideExpression { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/InterfaceConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/InterfaceConstructor.qll new file mode 100644 index 000000000000..5eacddf2b0c5 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/InterfaceConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `Interface` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `Interface` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructInterface(Raw::Interface id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/InterfaceImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/InterfaceImpl.qll new file mode 100644 index 000000000000..4eb8e3e8bde8 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/InterfaceImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `Interface`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Interface + +/** + * INTERNAL: This module contains the customizable definition of `Interface` and should not + * be referenced directly. + */ +module Impl { + class Interface extends Generated::Interface { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/IntrinsicAttributeLiteralConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/IntrinsicAttributeLiteralConstructor.qll new file mode 100644 index 000000000000..8e773ede264d --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/IntrinsicAttributeLiteralConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `IntrinsicAttributeLiteral` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `IntrinsicAttributeLiteral` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructIntrinsicAttributeLiteral(Raw::IntrinsicAttributeLiteral id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/IntrinsicAttributeLiteralImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/IntrinsicAttributeLiteralImpl.qll new file mode 100644 index 000000000000..80862a826337 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/IntrinsicAttributeLiteralImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `IntrinsicAttributeLiteral`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.IntrinsicAttributeLiteral + +/** + * INTERNAL: This module contains the customizable definition of `IntrinsicAttributeLiteral` and should not + * be referenced directly. + */ +module Impl { + class IntrinsicAttributeLiteral extends Generated::IntrinsicAttributeLiteral { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/IntrinsicConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/IntrinsicConstructor.qll new file mode 100644 index 000000000000..2acbd642c78d --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/IntrinsicConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `Intrinsic` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `Intrinsic` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructIntrinsic(Raw::Intrinsic id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/IntrinsicImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/IntrinsicImpl.qll new file mode 100644 index 000000000000..befab0c5343b --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/IntrinsicImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `Intrinsic`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Intrinsic + +/** + * INTERNAL: This module contains the customizable definition of `Intrinsic` and should not + * be referenced directly. + */ +module Impl { + class Intrinsic extends Generated::Intrinsic { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/IsAsExpressionImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/IsAsExpressionImpl.qll new file mode 100644 index 000000000000..d880fe5cf2b9 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/IsAsExpressionImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `IsAsExpression`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.IsAsExpression + +/** + * INTERNAL: This module contains the customizable definition of `IsAsExpression` and should not + * be referenced directly. + */ +module Impl { + class IsAsExpression extends Generated::IsAsExpression { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/IsClrExpressionConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/IsClrExpressionConstructor.qll new file mode 100644 index 000000000000..dfceadecb0af --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/IsClrExpressionConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `IsClrExpression` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `IsClrExpression` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructIsClrExpression(Raw::IsClrExpression id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/IsClrExpressionImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/IsClrExpressionImpl.qll new file mode 100644 index 000000000000..be480f8ec13b --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/IsClrExpressionImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `IsClrExpression`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.IsClrExpression + +/** + * INTERNAL: This module contains the customizable definition of `IsClrExpression` and should not + * be referenced directly. + */ +module Impl { + class IsClrExpression extends Generated::IsClrExpression { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/IsExpressionConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/IsExpressionConstructor.qll new file mode 100644 index 000000000000..382a358d47b5 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/IsExpressionConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `IsExpression` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `IsExpression` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructIsExpression(Raw::IsExpression id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/IsExpressionImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/IsExpressionImpl.qll new file mode 100644 index 000000000000..22144b90a07d --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/IsExpressionImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `IsExpression`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.IsExpression + +/** + * INTERNAL: This module contains the customizable definition of `IsExpression` and should not + * be referenced directly. + */ +module Impl { + class IsExpression extends Generated::IsExpression { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/JoinSpecificationConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/JoinSpecificationConstructor.qll new file mode 100644 index 000000000000..05b9a3ce5745 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/JoinSpecificationConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `JoinSpecification` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `JoinSpecification` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructJoinSpecification(Raw::JoinSpecification id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/JoinSpecificationImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/JoinSpecificationImpl.qll new file mode 100644 index 000000000000..b53c2902e8db --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/JoinSpecificationImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `JoinSpecification`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.JoinSpecification + +/** + * INTERNAL: This module contains the customizable definition of `JoinSpecification` and should not + * be referenced directly. + */ +module Impl { + class JoinSpecification extends Generated::JoinSpecification { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/LessThanExpressionConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/LessThanExpressionConstructor.qll new file mode 100644 index 000000000000..c63b67a91c17 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/LessThanExpressionConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `LessThanExpression` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `LessThanExpression` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructLessThanExpression(Raw::LessThanExpression id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/LessThanExpressionImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/LessThanExpressionImpl.qll new file mode 100644 index 000000000000..85a3e3c563e9 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/LessThanExpressionImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `LessThanExpression`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.LessThanExpression + +/** + * INTERNAL: This module contains the customizable definition of `LessThanExpression` and should not + * be referenced directly. + */ +module Impl { + class LessThanExpression extends Generated::LessThanExpression { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/LessThanOrEqualExpressionConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/LessThanOrEqualExpressionConstructor.qll new file mode 100644 index 000000000000..d04c5db3424a --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/LessThanOrEqualExpressionConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `LessThanOrEqualExpression` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `LessThanOrEqualExpression` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructLessThanOrEqualExpression(Raw::LessThanOrEqualExpression id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/LessThanOrEqualExpressionImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/LessThanOrEqualExpressionImpl.qll new file mode 100644 index 000000000000..8d46f1fe96a4 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/LessThanOrEqualExpressionImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `LessThanOrEqualExpression`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.LessThanOrEqualExpression + +/** + * INTERNAL: This module contains the customizable definition of `LessThanOrEqualExpression` and should not + * be referenced directly. + */ +module Impl { + class LessThanOrEqualExpression extends Generated::LessThanOrEqualExpression { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/LikeExpressionConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/LikeExpressionConstructor.qll new file mode 100644 index 000000000000..7a904de58457 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/LikeExpressionConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `LikeExpression` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `LikeExpression` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructLikeExpression(Raw::LikeExpression id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/LikeExpressionImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/LikeExpressionImpl.qll new file mode 100644 index 000000000000..e044d1d31997 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/LikeExpressionImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `LikeExpression`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.LikeExpression + +/** + * INTERNAL: This module contains the customizable definition of `LikeExpression` and should not + * be referenced directly. + */ +module Impl { + class LikeExpression extends Generated::LikeExpression { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/LiteralExpressionImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/LiteralExpressionImpl.qll new file mode 100644 index 000000000000..0e3b7ba06b9d --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/LiteralExpressionImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `LiteralExpression`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.LiteralExpression + +/** + * INTERNAL: This module contains the customizable definition of `LiteralExpression` and should not + * be referenced directly. + */ +module Impl { + class LiteralExpression extends Generated::LiteralExpression { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/LocalDeclarationImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/LocalDeclarationImpl.qll new file mode 100644 index 000000000000..e93b87bef03c --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/LocalDeclarationImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `LocalDeclaration`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.LocalDeclaration + +/** + * INTERNAL: This module contains the customizable definition of `LocalDeclaration` and should not + * be referenced directly. + */ +module Impl { + class LocalDeclaration extends Generated::LocalDeclaration { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/LocalDeclarationsStatementConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/LocalDeclarationsStatementConstructor.qll new file mode 100644 index 000000000000..14a95487f4f6 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/LocalDeclarationsStatementConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `LocalDeclarationsStatement` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `LocalDeclarationsStatement` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructLocalDeclarationsStatement(Raw::LocalDeclarationsStatement id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/LocalDeclarationsStatementImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/LocalDeclarationsStatementImpl.qll new file mode 100644 index 000000000000..a3bc973461f9 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/LocalDeclarationsStatementImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `LocalDeclarationsStatement`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.LocalDeclarationsStatement + +/** + * INTERNAL: This module contains the customizable definition of `LocalDeclarationsStatement` and should not + * be referenced directly. + */ +module Impl { + class LocalDeclarationsStatement extends Generated::LocalDeclarationsStatement { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/LocatableImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/LocatableImpl.qll new file mode 100644 index 000000000000..343815f94d77 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/LocatableImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `Locatable`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Locatable + +/** + * INTERNAL: This module contains the customizable definition of `Locatable` and should not + * be referenced directly. + */ +module Impl { + class Locatable extends Generated::Locatable { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/LocationConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/LocationConstructor.qll new file mode 100644 index 000000000000..142299fb5460 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/LocationConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `Location` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `Location` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructLocation(Raw::Location id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/LocationImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/LocationImpl.qll new file mode 100644 index 000000000000..4900acdad7a9 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/LocationImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `Location`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Location + +/** + * INTERNAL: This module contains the customizable definition of `Location` and should not + * be referenced directly. + */ +module Impl { + class Location extends Generated::Location { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/MaxAggregateSelectionConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/MaxAggregateSelectionConstructor.qll new file mode 100644 index 000000000000..ae33d8262106 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/MaxAggregateSelectionConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `MaxAggregateSelection` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `MaxAggregateSelection` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructMaxAggregateSelection(Raw::MaxAggregateSelection id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/MaxAggregateSelectionImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/MaxAggregateSelectionImpl.qll new file mode 100644 index 000000000000..c2a62207c7cb --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/MaxAggregateSelectionImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `MaxAggregateSelection`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.MaxAggregateSelection + +/** + * INTERNAL: This module contains the customizable definition of `MaxAggregateSelection` and should not + * be referenced directly. + */ +module Impl { + class MaxAggregateSelection extends Generated::MaxAggregateSelection { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/MethodConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/MethodConstructor.qll new file mode 100644 index 000000000000..9b6ac6529b4e --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/MethodConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `Method` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `Method` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructMethod(Raw::Method id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/MethodImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/MethodImpl.qll new file mode 100644 index 000000000000..c9cde7edc413 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/MethodImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `Method`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Method + +/** + * INTERNAL: This module contains the customizable definition of `Method` and should not + * be referenced directly. + */ +module Impl { + class Method extends Generated::Method { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/MethodOrDelegateImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/MethodOrDelegateImpl.qll new file mode 100644 index 000000000000..a9605f8901e0 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/MethodOrDelegateImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `MethodOrDelegate`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.MethodOrDelegate + +/** + * INTERNAL: This module contains the customizable definition of `MethodOrDelegate` and should not + * be referenced directly. + */ +module Impl { + class MethodOrDelegate extends Generated::MethodOrDelegate { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/MinAggregateSelectionConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/MinAggregateSelectionConstructor.qll new file mode 100644 index 000000000000..46370b250230 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/MinAggregateSelectionConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `MinAggregateSelection` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `MinAggregateSelection` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructMinAggregateSelection(Raw::MinAggregateSelection id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/MinAggregateSelectionImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/MinAggregateSelectionImpl.qll new file mode 100644 index 000000000000..5307badd30fe --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/MinAggregateSelectionImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `MinAggregateSelection`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.MinAggregateSelection + +/** + * INTERNAL: This module contains the customizable definition of `MinAggregateSelection` and should not + * be referenced directly. + */ +module Impl { + class MinAggregateSelection extends Generated::MinAggregateSelection { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/ModExpressionConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/ModExpressionConstructor.qll new file mode 100644 index 000000000000..50375c62343b --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/ModExpressionConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `ModExpression` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `ModExpression` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructModExpression(Raw::ModExpression id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/ModExpressionImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/ModExpressionImpl.qll new file mode 100644 index 000000000000..3af512040cd4 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/ModExpressionImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `ModExpression`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.ModExpression + +/** + * INTERNAL: This module contains the customizable definition of `ModExpression` and should not + * be referenced directly. + */ +module Impl { + class ModExpression extends Generated::ModExpression { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/ModelElementImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/ModelElementImpl.qll new file mode 100644 index 000000000000..a4111078976b --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/ModelElementImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `ModelElement`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.ModelElement + +/** + * INTERNAL: This module contains the customizable definition of `ModelElement` and should not + * be referenced directly. + */ +module Impl { + class ModelElement extends Generated::ModelElement { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/ModelElementUsingEntryConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/ModelElementUsingEntryConstructor.qll new file mode 100644 index 000000000000..30b501f4c0d1 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/ModelElementUsingEntryConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `ModelElementUsingEntry` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `ModelElementUsingEntry` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructModelElementUsingEntry(Raw::ModelElementUsingEntry id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/ModelElementUsingEntryImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/ModelElementUsingEntryImpl.qll new file mode 100644 index 000000000000..a4425aa94508 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/ModelElementUsingEntryImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `ModelElementUsingEntry`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.ModelElementUsingEntry + +/** + * INTERNAL: This module contains the customizable definition of `ModelElementUsingEntry` and should not + * be referenced directly. + */ +module Impl { + class ModelElementUsingEntry extends Generated::ModelElementUsingEntry { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/ModifierConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/ModifierConstructor.qll new file mode 100644 index 000000000000..7244c0bf6029 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/ModifierConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `Modifier` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `Modifier` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructModifier(Raw::Modifier id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/ModifierImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/ModifierImpl.qll new file mode 100644 index 000000000000..2d2c4cbd4bad --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/ModifierImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `Modifier`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Modifier + +/** + * INTERNAL: This module contains the customizable definition of `Modifier` and should not + * be referenced directly. + */ +module Impl { + class Modifier extends Generated::Modifier { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/MoveCursorStatementConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/MoveCursorStatementConstructor.qll new file mode 100644 index 000000000000..3ac87ef9721a --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/MoveCursorStatementConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `MoveCursorStatement` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `MoveCursorStatement` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructMoveCursorStatement(Raw::MoveCursorStatement id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/MoveCursorStatementImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/MoveCursorStatementImpl.qll new file mode 100644 index 000000000000..35543c9e014b --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/MoveCursorStatementImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `MoveCursorStatement`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.MoveCursorStatement + +/** + * INTERNAL: This module contains the customizable definition of `MoveCursorStatement` and should not + * be referenced directly. + */ +module Impl { + class MoveCursorStatement extends Generated::MoveCursorStatement { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/MultiplyExpressionConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/MultiplyExpressionConstructor.qll new file mode 100644 index 000000000000..86e9f44937ec --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/MultiplyExpressionConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `MultiplyExpression` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `MultiplyExpression` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructMultiplyExpression(Raw::MultiplyExpression id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/MultiplyExpressionImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/MultiplyExpressionImpl.qll new file mode 100644 index 000000000000..9b8f0f62bd77 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/MultiplyExpressionImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `MultiplyExpression`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.MultiplyExpression + +/** + * INTERNAL: This module contains the customizable definition of `MultiplyExpression` and should not + * be referenced directly. + */ +module Impl { + class MultiplyExpression extends Generated::MultiplyExpression { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/NamedFieldReferenceConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/NamedFieldReferenceConstructor.qll new file mode 100644 index 000000000000..77fa8672ec46 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/NamedFieldReferenceConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `NamedFieldReference` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `NamedFieldReference` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructNamedFieldReference(Raw::NamedFieldReference id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/NamedFieldReferenceImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/NamedFieldReferenceImpl.qll new file mode 100644 index 000000000000..bc11d248e4d9 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/NamedFieldReferenceImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `NamedFieldReference`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.NamedFieldReference + +/** + * INTERNAL: This module contains the customizable definition of `NamedFieldReference` and should not + * be referenced directly. + */ +module Impl { + class NamedFieldReference extends Generated::NamedFieldReference { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/NamedTypeImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/NamedTypeImpl.qll new file mode 100644 index 000000000000..52cadb30e4a8 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/NamedTypeImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `NamedType`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.NamedType + +/** + * INTERNAL: This module contains the customizable definition of `NamedType` and should not + * be referenced directly. + */ +module Impl { + class NamedType extends Generated::NamedType { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/NamedTypeInternalConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/NamedTypeInternalConstructor.qll new file mode 100644 index 000000000000..ef797d6bb806 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/NamedTypeInternalConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `NamedTypeInternal` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `NamedTypeInternal` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructNamedTypeInternal(Raw::NamedTypeInternal id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/NamedTypeInternalImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/NamedTypeInternalImpl.qll new file mode 100644 index 000000000000..84711f4168b3 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/NamedTypeInternalImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `NamedTypeInternal`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.NamedTypeInternal + +/** + * INTERNAL: This module contains the customizable definition of `NamedTypeInternal` and should not + * be referenced directly. + */ +module Impl { + class NamedTypeInternal extends Generated::NamedTypeInternal { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/NewCallConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/NewCallConstructor.qll new file mode 100644 index 000000000000..868b56a3a579 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/NewCallConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `NewCall` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `NewCall` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructNewCall(Raw::NewCall id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/NewCallImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/NewCallImpl.qll new file mode 100644 index 000000000000..7d0d7bd18905 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/NewCallImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `NewCall`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.NewCall + +/** + * INTERNAL: This module contains the customizable definition of `NewCall` and should not + * be referenced directly. + */ +module Impl { + class NewCall extends Generated::NewCall { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/NewClrArrayExpressionConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/NewClrArrayExpressionConstructor.qll new file mode 100644 index 000000000000..a758cf511841 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/NewClrArrayExpressionConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `NewClrArrayExpression` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `NewClrArrayExpression` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructNewClrArrayExpression(Raw::NewClrArrayExpression id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/NewClrArrayExpressionImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/NewClrArrayExpressionImpl.qll new file mode 100644 index 000000000000..0a54ebb06a80 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/NewClrArrayExpressionImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `NewClrArrayExpression`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.NewClrArrayExpression + +/** + * INTERNAL: This module contains the customizable definition of `NewClrArrayExpression` and should not + * be referenced directly. + */ +module Impl { + class NewClrArrayExpression extends Generated::NewClrArrayExpression { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/NewClrCallConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/NewClrCallConstructor.qll new file mode 100644 index 000000000000..3619606c235b --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/NewClrCallConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `NewClrCall` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `NewClrCall` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructNewClrCall(Raw::NewClrCall id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/NewClrCallImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/NewClrCallImpl.qll new file mode 100644 index 000000000000..e48561fa26b3 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/NewClrCallImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `NewClrCall`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.NewClrCall + +/** + * INTERNAL: This module contains the customizable definition of `NewClrCall` and should not + * be referenced directly. + */ +module Impl { + class NewClrCall extends Generated::NewClrCall { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/NextExpressionConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/NextExpressionConstructor.qll new file mode 100644 index 000000000000..76c650b193db --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/NextExpressionConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `NextExpression` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `NextExpression` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructNextExpression(Raw::NextExpression id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/NextExpressionImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/NextExpressionImpl.qll new file mode 100644 index 000000000000..4482ad4a6beb --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/NextExpressionImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `NextExpression`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.NextExpression + +/** + * INTERNAL: This module contains the customizable definition of `NextExpression` and should not + * be referenced directly. + */ +module Impl { + class NextExpression extends Generated::NextExpression { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/NotEqualExpressionConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/NotEqualExpressionConstructor.qll new file mode 100644 index 000000000000..0e3e8c9f9130 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/NotEqualExpressionConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `NotEqualExpression` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `NotEqualExpression` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructNotEqualExpression(Raw::NotEqualExpression id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/NotEqualExpressionImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/NotEqualExpressionImpl.qll new file mode 100644 index 000000000000..3bd29b378f88 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/NotEqualExpressionImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `NotEqualExpression`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.NotEqualExpression + +/** + * INTERNAL: This module contains the customizable definition of `NotEqualExpression` and should not + * be referenced directly. + */ +module Impl { + class NotEqualExpression extends Generated::NotEqualExpression { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/NotExpressionConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/NotExpressionConstructor.qll new file mode 100644 index 000000000000..2255e6b88a54 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/NotExpressionConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `NotExpression` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `NotExpression` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructNotExpression(Raw::NotExpression id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/NotExpressionImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/NotExpressionImpl.qll new file mode 100644 index 000000000000..d1b7abb7cee1 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/NotExpressionImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `NotExpression`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.NotExpression + +/** + * INTERNAL: This module contains the customizable definition of `NotExpression` and should not + * be referenced directly. + */ +module Impl { + class NotExpression extends Generated::NotExpression { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/NullLiteralExpressionConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/NullLiteralExpressionConstructor.qll new file mode 100644 index 000000000000..32380b4a2fa5 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/NullLiteralExpressionConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `NullLiteralExpression` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `NullLiteralExpression` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructNullLiteralExpression(Raw::NullLiteralExpression id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/NullLiteralExpressionImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/NullLiteralExpressionImpl.qll new file mode 100644 index 000000000000..c10edaa20f9d --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/NullLiteralExpressionImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `NullLiteralExpression`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.NullLiteralExpression + +/** + * INTERNAL: This module contains the customizable definition of `NullLiteralExpression` and should not + * be referenced directly. + */ +module Impl { + class NullLiteralExpression extends Generated::NullLiteralExpression { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/NumberedFieldReferenceConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/NumberedFieldReferenceConstructor.qll new file mode 100644 index 000000000000..fa2eb41970e4 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/NumberedFieldReferenceConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `NumberedFieldReference` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `NumberedFieldReference` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructNumberedFieldReference(Raw::NumberedFieldReference id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/NumberedFieldReferenceImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/NumberedFieldReferenceImpl.qll new file mode 100644 index 000000000000..8a159dea047b --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/NumberedFieldReferenceImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `NumberedFieldReference`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.NumberedFieldReference + +/** + * INTERNAL: This module contains the customizable definition of `NumberedFieldReference` and should not + * be referenced directly. + */ +module Impl { + class NumberedFieldReference extends Generated::NumberedFieldReference { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/OrExpressionConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/OrExpressionConstructor.qll new file mode 100644 index 000000000000..c2740ba92b9d --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/OrExpressionConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `OrExpression` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `OrExpression` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructOrExpression(Raw::OrExpression id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/OrExpressionImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/OrExpressionImpl.qll new file mode 100644 index 000000000000..6b5a09920d58 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/OrExpressionImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `OrExpression`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.OrExpression + +/** + * INTERNAL: This module contains the customizable definition of `OrExpression` and should not + * be referenced directly. + */ +module Impl { + class OrExpression extends Generated::OrExpression { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/OrderElementImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/OrderElementImpl.qll new file mode 100644 index 000000000000..09d4574ae220 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/OrderElementImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `OrderElement`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.OrderElement + +/** + * INTERNAL: This module contains the customizable definition of `OrderElement` and should not + * be referenced directly. + */ +module Impl { + class OrderElement extends Generated::OrderElement { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/ParameterDeclarationConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/ParameterDeclarationConstructor.qll new file mode 100644 index 000000000000..1055dffe7557 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/ParameterDeclarationConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `ParameterDeclaration` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `ParameterDeclaration` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructParameterDeclaration(Raw::ParameterDeclaration id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/ParameterDeclarationImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/ParameterDeclarationImpl.qll new file mode 100644 index 000000000000..8460422ce6d1 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/ParameterDeclarationImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `ParameterDeclaration`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.ParameterDeclaration + +/** + * INTERNAL: This module contains the customizable definition of `ParameterDeclaration` and should not + * be referenced directly. + */ +module Impl { + class ParameterDeclaration extends Generated::ParameterDeclaration { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/PhysicalAndExpressionConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/PhysicalAndExpressionConstructor.qll new file mode 100644 index 000000000000..4411897de159 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/PhysicalAndExpressionConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `PhysicalAndExpression` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `PhysicalAndExpression` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructPhysicalAndExpression(Raw::PhysicalAndExpression id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/PhysicalAndExpressionImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/PhysicalAndExpressionImpl.qll new file mode 100644 index 000000000000..7f325ddd2ba7 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/PhysicalAndExpressionImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `PhysicalAndExpression`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.PhysicalAndExpression + +/** + * INTERNAL: This module contains the customizable definition of `PhysicalAndExpression` and should not + * be referenced directly. + */ +module Impl { + class PhysicalAndExpression extends Generated::PhysicalAndExpression { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/PhysicalNotExpressionConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/PhysicalNotExpressionConstructor.qll new file mode 100644 index 000000000000..6d3f22de011c --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/PhysicalNotExpressionConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `PhysicalNotExpression` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `PhysicalNotExpression` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructPhysicalNotExpression(Raw::PhysicalNotExpression id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/PhysicalNotExpressionImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/PhysicalNotExpressionImpl.qll new file mode 100644 index 000000000000..ac5b2f92164a --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/PhysicalNotExpressionImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `PhysicalNotExpression`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.PhysicalNotExpression + +/** + * INTERNAL: This module contains the customizable definition of `PhysicalNotExpression` and should not + * be referenced directly. + */ +module Impl { + class PhysicalNotExpression extends Generated::PhysicalNotExpression { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/PhysicalOrExpressionConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/PhysicalOrExpressionConstructor.qll new file mode 100644 index 000000000000..eb7e3f7ad894 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/PhysicalOrExpressionConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `PhysicalOrExpression` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `PhysicalOrExpression` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructPhysicalOrExpression(Raw::PhysicalOrExpression id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/PhysicalOrExpressionImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/PhysicalOrExpressionImpl.qll new file mode 100644 index 000000000000..925a2f17c87c --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/PhysicalOrExpressionImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `PhysicalOrExpression`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.PhysicalOrExpression + +/** + * INTERNAL: This module contains the customizable definition of `PhysicalOrExpression` and should not + * be referenced directly. + */ +module Impl { + class PhysicalOrExpression extends Generated::PhysicalOrExpression { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/PhysicalXorExpressionConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/PhysicalXorExpressionConstructor.qll new file mode 100644 index 000000000000..3e845962bf66 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/PhysicalXorExpressionConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `PhysicalXorExpression` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `PhysicalXorExpression` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructPhysicalXorExpression(Raw::PhysicalXorExpression id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/PhysicalXorExpressionImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/PhysicalXorExpressionImpl.qll new file mode 100644 index 000000000000..2d34252072b1 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/PhysicalXorExpressionImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `PhysicalXorExpression`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.PhysicalXorExpression + +/** + * INTERNAL: This module contains the customizable definition of `PhysicalXorExpression` and should not + * be referenced directly. + */ +module Impl { + class PhysicalXorExpression extends Generated::PhysicalXorExpression { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/PlaceholderConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/PlaceholderConstructor.qll new file mode 100644 index 000000000000..0388a22032ee --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/PlaceholderConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `Placeholder` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `Placeholder` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructPlaceholder(Raw::Placeholder id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/PlaceholderImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/PlaceholderImpl.qll new file mode 100644 index 000000000000..349fe133f37e --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/PlaceholderImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `Placeholder`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Placeholder + +/** + * INTERNAL: This module contains the customizable definition of `Placeholder` and should not + * be referenced directly. + */ +module Impl { + class Placeholder extends Generated::Placeholder { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/PrintStatementConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/PrintStatementConstructor.qll new file mode 100644 index 000000000000..e7c2a9401287 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/PrintStatementConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `PrintStatement` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `PrintStatement` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructPrintStatement(Raw::PrintStatement id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/PrintStatementImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/PrintStatementImpl.qll new file mode 100644 index 000000000000..a6c6b5e2c12a --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/PrintStatementImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `PrintStatement`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.PrintStatement + +/** + * INTERNAL: This module contains the customizable definition of `PrintStatement` and should not + * be referenced directly. + */ +module Impl { + class PrintStatement extends Generated::PrintStatement { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/ProvidedTypeConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/ProvidedTypeConstructor.qll new file mode 100644 index 000000000000..54c489ade638 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/ProvidedTypeConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `ProvidedType` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `ProvidedType` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructProvidedType(Raw::ProvidedType id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/ProvidedTypeImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/ProvidedTypeImpl.qll new file mode 100644 index 000000000000..b51e339d7bcb --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/ProvidedTypeImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `ProvidedType`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.ProvidedType + +/** + * INTERNAL: This module contains the customizable definition of `ProvidedType` and should not + * be referenced directly. + */ +module Impl { + class ProvidedType extends Generated::ProvidedType { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/ProvidedTypeStaticCallConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/ProvidedTypeStaticCallConstructor.qll new file mode 100644 index 000000000000..f5a49ce742d0 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/ProvidedTypeStaticCallConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `ProvidedTypeStaticCall` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `ProvidedTypeStaticCall` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructProvidedTypeStaticCall(Raw::ProvidedTypeStaticCall id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/ProvidedTypeStaticCallImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/ProvidedTypeStaticCallImpl.qll new file mode 100644 index 000000000000..7901bee3699a --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/ProvidedTypeStaticCallImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `ProvidedTypeStaticCall`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.ProvidedTypeStaticCall + +/** + * INTERNAL: This module contains the customizable definition of `ProvidedTypeStaticCall` and should not + * be referenced directly. + */ +module Impl { + class ProvidedTypeStaticCall extends Generated::ProvidedTypeStaticCall { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/QualifiedCallConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/QualifiedCallConstructor.qll new file mode 100644 index 000000000000..97c83d8b854e --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/QualifiedCallConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `QualifiedCall` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `QualifiedCall` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructQualifiedCall(Raw::QualifiedCall id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/QualifiedCallImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/QualifiedCallImpl.qll new file mode 100644 index 000000000000..a4714475cc02 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/QualifiedCallImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `QualifiedCall`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.QualifiedCall + +/** + * INTERNAL: This module contains the customizable definition of `QualifiedCall` and should not + * be referenced directly. + */ +module Impl { + class QualifiedCall extends Generated::QualifiedCall { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/QualifiedFieldConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/QualifiedFieldConstructor.qll new file mode 100644 index 000000000000..c9075ffffbad --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/QualifiedFieldConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `QualifiedField` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `QualifiedField` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructQualifiedField(Raw::QualifiedField id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/QualifiedFieldImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/QualifiedFieldImpl.qll new file mode 100644 index 000000000000..8a8e64e5791d --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/QualifiedFieldImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `QualifiedField`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.QualifiedField + +/** + * INTERNAL: This module contains the customizable definition of `QualifiedField` and should not + * be referenced directly. + */ +module Impl { + class QualifiedField extends Generated::QualifiedField { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/QualifiedInstanceNameConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/QualifiedInstanceNameConstructor.qll new file mode 100644 index 000000000000..fcbc703e2637 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/QualifiedInstanceNameConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `QualifiedInstanceName` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `QualifiedInstanceName` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructQualifiedInstanceName(Raw::QualifiedInstanceName id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/QualifiedInstanceNameImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/QualifiedInstanceNameImpl.qll new file mode 100644 index 000000000000..fe1dc0a7019f --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/QualifiedInstanceNameImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `QualifiedInstanceName`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.QualifiedInstanceName + +/** + * INTERNAL: This module contains the customizable definition of `QualifiedInstanceName` and should not + * be referenced directly. + */ +module Impl { + class QualifiedInstanceName extends Generated::QualifiedInstanceName { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/QualifiedNumberedFieldConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/QualifiedNumberedFieldConstructor.qll new file mode 100644 index 000000000000..3b8bc69af9f0 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/QualifiedNumberedFieldConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `QualifiedNumberedField` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `QualifiedNumberedField` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructQualifiedNumberedField(Raw::QualifiedNumberedField id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/QualifiedNumberedFieldImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/QualifiedNumberedFieldImpl.qll new file mode 100644 index 000000000000..7e9c5cc6ce4d --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/QualifiedNumberedFieldImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `QualifiedNumberedField`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.QualifiedNumberedField + +/** + * INTERNAL: This module contains the customizable definition of `QualifiedNumberedField` and should not + * be referenced directly. + */ +module Impl { + class QualifiedNumberedField extends Generated::QualifiedNumberedField { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/QualifiedStaticCallConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/QualifiedStaticCallConstructor.qll new file mode 100644 index 000000000000..6de8419a884b --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/QualifiedStaticCallConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `QualifiedStaticCall` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `QualifiedStaticCall` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructQualifiedStaticCall(Raw::QualifiedStaticCall id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/QualifiedStaticCallImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/QualifiedStaticCallImpl.qll new file mode 100644 index 000000000000..d092634e7d35 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/QualifiedStaticCallImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `QualifiedStaticCall`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.QualifiedStaticCall + +/** + * INTERNAL: This module contains the customizable definition of `QualifiedStaticCall` and should not + * be referenced directly. + */ +module Impl { + class QualifiedStaticCall extends Generated::QualifiedStaticCall { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/QualifiedStaticFieldConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/QualifiedStaticFieldConstructor.qll new file mode 100644 index 000000000000..efd1ace2c9a0 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/QualifiedStaticFieldConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `QualifiedStaticField` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `QualifiedStaticField` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructQualifiedStaticField(Raw::QualifiedStaticField id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/QualifiedStaticFieldExpressionConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/QualifiedStaticFieldExpressionConstructor.qll new file mode 100644 index 000000000000..01577f84a997 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/QualifiedStaticFieldExpressionConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `QualifiedStaticFieldExpression` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `QualifiedStaticFieldExpression` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructQualifiedStaticFieldExpression(Raw::QualifiedStaticFieldExpression id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/QualifiedStaticFieldExpressionImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/QualifiedStaticFieldExpressionImpl.qll new file mode 100644 index 000000000000..8d85a26b9acd --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/QualifiedStaticFieldExpressionImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `QualifiedStaticFieldExpression`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.QualifiedStaticFieldExpression + +/** + * INTERNAL: This module contains the customizable definition of `QualifiedStaticFieldExpression` and should not + * be referenced directly. + */ +module Impl { + class QualifiedStaticFieldExpression extends Generated::QualifiedStaticFieldExpression { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/QualifiedStaticFieldImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/QualifiedStaticFieldImpl.qll new file mode 100644 index 000000000000..26680c2f0f7c --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/QualifiedStaticFieldImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `QualifiedStaticField`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.QualifiedStaticField + +/** + * INTERNAL: This module contains the customizable definition of `QualifiedStaticField` and should not + * be referenced directly. + */ +module Impl { + class QualifiedStaticField extends Generated::QualifiedStaticField { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/QualifierImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/QualifierImpl.qll new file mode 100644 index 000000000000..060fbf2971de --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/QualifierImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `Qualifier`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Qualifier + +/** + * INTERNAL: This module contains the customizable definition of `Qualifier` and should not + * be referenced directly. + */ +module Impl { + class Qualifier extends Generated::Qualifier { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/QueryConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/QueryConstructor.qll new file mode 100644 index 000000000000..3958fd23356c --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/QueryConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `Query` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `Query` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructQuery(Raw::Query id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/QueryDataSourceConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/QueryDataSourceConstructor.qll new file mode 100644 index 000000000000..a511ac72db16 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/QueryDataSourceConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `QueryDataSource` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `QueryDataSource` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructQueryDataSource(Raw::QueryDataSource id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/QueryDataSourceHavingConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/QueryDataSourceHavingConstructor.qll new file mode 100644 index 000000000000..1e4f6dad7d57 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/QueryDataSourceHavingConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `QueryDataSourceHaving` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `QueryDataSourceHaving` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructQueryDataSourceHaving(Raw::QueryDataSourceHaving id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/QueryDataSourceHavingImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/QueryDataSourceHavingImpl.qll new file mode 100644 index 000000000000..30af9da4a42a --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/QueryDataSourceHavingImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `QueryDataSourceHaving`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.QueryDataSourceHaving + +/** + * INTERNAL: This module contains the customizable definition of `QueryDataSourceHaving` and should not + * be referenced directly. + */ +module Impl { + class QueryDataSourceHaving extends Generated::QueryDataSourceHaving { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/QueryDataSourceImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/QueryDataSourceImpl.qll new file mode 100644 index 000000000000..0fd1aa42a5cd --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/QueryDataSourceImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `QueryDataSource`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.QueryDataSource + +/** + * INTERNAL: This module contains the customizable definition of `QueryDataSource` and should not + * be referenced directly. + */ +module Impl { + class QueryDataSource extends Generated::QueryDataSource { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/QueryDataSourceRangeConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/QueryDataSourceRangeConstructor.qll new file mode 100644 index 000000000000..e7a0d2423fec --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/QueryDataSourceRangeConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `QueryDataSourceRange` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `QueryDataSourceRange` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructQueryDataSourceRange(Raw::QueryDataSourceRange id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/QueryDataSourceRangeImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/QueryDataSourceRangeImpl.qll new file mode 100644 index 000000000000..585c9653affa --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/QueryDataSourceRangeImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `QueryDataSourceRange`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.QueryDataSourceRange + +/** + * INTERNAL: This module contains the customizable definition of `QueryDataSourceRange` and should not + * be referenced directly. + */ +module Impl { + class QueryDataSourceRange extends Generated::QueryDataSourceRange { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/QueryDataSourceRelationConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/QueryDataSourceRelationConstructor.qll new file mode 100644 index 000000000000..589f25a8012f --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/QueryDataSourceRelationConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `QueryDataSourceRelation` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `QueryDataSourceRelation` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructQueryDataSourceRelation(Raw::QueryDataSourceRelation id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/QueryDataSourceRelationImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/QueryDataSourceRelationImpl.qll new file mode 100644 index 000000000000..b1fef2b14c58 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/QueryDataSourceRelationImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `QueryDataSourceRelation`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.QueryDataSourceRelation + +/** + * INTERNAL: This module contains the customizable definition of `QueryDataSourceRelation` and should not + * be referenced directly. + */ +module Impl { + class QueryDataSourceRelation extends Generated::QueryDataSourceRelation { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/QueryImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/QueryImpl.qll new file mode 100644 index 000000000000..77a65ccfc1bb --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/QueryImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `Query`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Query + +/** + * INTERNAL: This module contains the customizable definition of `Query` and should not + * be referenced directly. + */ +module Impl { + class Query extends Generated::Query { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/QueryModelElementConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/QueryModelElementConstructor.qll new file mode 100644 index 000000000000..a3b8aedeae9b --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/QueryModelElementConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `QueryModelElement` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `QueryModelElement` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructQueryModelElement(Raw::QueryModelElement id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/QueryModelElementImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/QueryModelElementImpl.qll new file mode 100644 index 000000000000..335e48e345be --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/QueryModelElementImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `QueryModelElement`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.QueryModelElement + +/** + * INTERNAL: This module contains the customizable definition of `QueryModelElement` and should not + * be referenced directly. + */ +module Impl { + class QueryModelElement extends Generated::QueryModelElement { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/RealLiteralExpressionConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/RealLiteralExpressionConstructor.qll new file mode 100644 index 000000000000..d6867b283c3e --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/RealLiteralExpressionConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `RealLiteralExpression` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `RealLiteralExpression` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructRealLiteralExpression(Raw::RealLiteralExpression id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/RealLiteralExpressionImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/RealLiteralExpressionImpl.qll new file mode 100644 index 000000000000..d1382293bcab --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/RealLiteralExpressionImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `RealLiteralExpression`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.RealLiteralExpression + +/** + * INTERNAL: This module contains the customizable definition of `RealLiteralExpression` and should not + * be referenced directly. + */ +module Impl { + class RealLiteralExpression extends Generated::RealLiteralExpression { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/RelationalExpressionImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/RelationalExpressionImpl.qll new file mode 100644 index 000000000000..493b149df282 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/RelationalExpressionImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `RelationalExpression`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.RelationalExpression + +/** + * INTERNAL: This module contains the customizable definition of `RelationalExpression` and should not + * be referenced directly. + */ +module Impl { + class RelationalExpression extends Generated::RelationalExpression { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/RetryStatementConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/RetryStatementConstructor.qll new file mode 100644 index 000000000000..f5440c9fab16 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/RetryStatementConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `RetryStatement` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `RetryStatement` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructRetryStatement(Raw::RetryStatement id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/RetryStatementImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/RetryStatementImpl.qll new file mode 100644 index 000000000000..f8291d1fdacb --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/RetryStatementImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `RetryStatement`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.RetryStatement + +/** + * INTERNAL: This module contains the customizable definition of `RetryStatement` and should not + * be referenced directly. + */ +module Impl { + class RetryStatement extends Generated::RetryStatement { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/ReturnStatementConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/ReturnStatementConstructor.qll new file mode 100644 index 000000000000..6cb1184cdab6 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/ReturnStatementConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `ReturnStatement` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `ReturnStatement` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructReturnStatement(Raw::ReturnStatement id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/ReturnStatementImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/ReturnStatementImpl.qll new file mode 100644 index 000000000000..d910a0b33255 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/ReturnStatementImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `ReturnStatement`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.ReturnStatement + +/** + * INTERNAL: This module contains the customizable definition of `ReturnStatement` and should not + * be referenced directly. + */ +module Impl { + class ReturnStatement extends Generated::ReturnStatement { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/SearchStatementConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/SearchStatementConstructor.qll new file mode 100644 index 000000000000..6b1afb3e46d4 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/SearchStatementConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `SearchStatement` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `SearchStatement` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructSearchStatement(Raw::SearchStatement id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/SearchStatementImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/SearchStatementImpl.qll new file mode 100644 index 000000000000..30f389ba2552 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/SearchStatementImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `SearchStatement`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.SearchStatement + +/** + * INTERNAL: This module contains the customizable definition of `SearchStatement` and should not + * be referenced directly. + */ +module Impl { + class SearchStatement extends Generated::SearchStatement { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/SelectionFieldImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/SelectionFieldImpl.qll new file mode 100644 index 000000000000..3c38642f201c --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/SelectionFieldImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `SelectionField`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.SelectionField + +/** + * INTERNAL: This module contains the customizable definition of `SelectionField` and should not + * be referenced directly. + */ +module Impl { + class SelectionField extends Generated::SelectionField { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/SelectionImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/SelectionImpl.qll new file mode 100644 index 000000000000..d93a122f4d24 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/SelectionImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `Selection`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Selection + +/** + * INTERNAL: This module contains the customizable definition of `Selection` and should not + * be referenced directly. + */ +module Impl { + class Selection extends Generated::Selection { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/ShiftLeftExpressionConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/ShiftLeftExpressionConstructor.qll new file mode 100644 index 000000000000..2b9cd722fc1a --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/ShiftLeftExpressionConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `ShiftLeftExpression` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `ShiftLeftExpression` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructShiftLeftExpression(Raw::ShiftLeftExpression id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/ShiftLeftExpressionImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/ShiftLeftExpressionImpl.qll new file mode 100644 index 000000000000..d5d4a11cd604 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/ShiftLeftExpressionImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `ShiftLeftExpression`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.ShiftLeftExpression + +/** + * INTERNAL: This module contains the customizable definition of `ShiftLeftExpression` and should not + * be referenced directly. + */ +module Impl { + class ShiftLeftExpression extends Generated::ShiftLeftExpression { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/ShiftRightExpressionConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/ShiftRightExpressionConstructor.qll new file mode 100644 index 000000000000..0040192fd36c --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/ShiftRightExpressionConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `ShiftRightExpression` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `ShiftRightExpression` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructShiftRightExpression(Raw::ShiftRightExpression id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/ShiftRightExpressionImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/ShiftRightExpressionImpl.qll new file mode 100644 index 000000000000..8375d67c040c --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/ShiftRightExpressionImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `ShiftRightExpression`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.ShiftRightExpression + +/** + * INTERNAL: This module contains the customizable definition of `ShiftRightExpression` and should not + * be referenced directly. + */ +module Impl { + class ShiftRightExpression extends Generated::ShiftRightExpression { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/SimpleFieldConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/SimpleFieldConstructor.qll new file mode 100644 index 000000000000..062a5d381df7 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/SimpleFieldConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `SimpleField` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `SimpleField` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructSimpleField(Raw::SimpleField id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/SimpleFieldImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/SimpleFieldImpl.qll new file mode 100644 index 000000000000..037e0185838f --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/SimpleFieldImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `SimpleField`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.SimpleField + +/** + * INTERNAL: This module contains the customizable definition of `SimpleField` and should not + * be referenced directly. + */ +module Impl { + class SimpleField extends Generated::SimpleField { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/SimpleInstanceNameConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/SimpleInstanceNameConstructor.qll new file mode 100644 index 000000000000..1e8198581271 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/SimpleInstanceNameConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `SimpleInstanceName` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `SimpleInstanceName` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructSimpleInstanceName(Raw::SimpleInstanceName id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/SimpleInstanceNameImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/SimpleInstanceNameImpl.qll new file mode 100644 index 000000000000..83b5964b2a55 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/SimpleInstanceNameImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `SimpleInstanceName`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.SimpleInstanceName + +/** + * INTERNAL: This module contains the customizable definition of `SimpleInstanceName` and should not + * be referenced directly. + */ +module Impl { + class SimpleInstanceName extends Generated::SimpleInstanceName { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/SimpleOrderElementConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/SimpleOrderElementConstructor.qll new file mode 100644 index 000000000000..341e290d6af9 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/SimpleOrderElementConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `SimpleOrderElement` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `SimpleOrderElement` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructSimpleOrderElement(Raw::SimpleOrderElement id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/SimpleOrderElementImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/SimpleOrderElementImpl.qll new file mode 100644 index 000000000000..ed0e27bb105c --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/SimpleOrderElementImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `SimpleOrderElement`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.SimpleOrderElement + +/** + * INTERNAL: This module contains the customizable definition of `SimpleOrderElement` and should not + * be referenced directly. + */ +module Impl { + class SimpleOrderElement extends Generated::SimpleOrderElement { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/SimpleQualifierImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/SimpleQualifierImpl.qll new file mode 100644 index 000000000000..afa3f502fdb0 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/SimpleQualifierImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `SimpleQualifier`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.SimpleQualifier + +/** + * INTERNAL: This module contains the customizable definition of `SimpleQualifier` and should not + * be referenced directly. + */ +module Impl { + class SimpleQualifier extends Generated::SimpleQualifier { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/SimpleQualifierInternalConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/SimpleQualifierInternalConstructor.qll new file mode 100644 index 000000000000..c44c20f37cf0 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/SimpleQualifierInternalConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `SimpleQualifierInternal` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `SimpleQualifierInternal` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructSimpleQualifierInternal(Raw::SimpleQualifierInternal id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/SimpleQualifierInternalImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/SimpleQualifierInternalImpl.qll new file mode 100644 index 000000000000..0f4ef624747c --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/SimpleQualifierInternalImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `SimpleQualifierInternal`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.SimpleQualifierInternal + +/** + * INTERNAL: This module contains the customizable definition of `SimpleQualifierInternal` and should not + * be referenced directly. + */ +module Impl { + class SimpleQualifierInternal extends Generated::SimpleQualifierInternal { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/StatementImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/StatementImpl.qll new file mode 100644 index 000000000000..96474ab0fed3 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/StatementImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `Statement`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Statement + +/** + * INTERNAL: This module contains the customizable definition of `Statement` and should not + * be referenced directly. + */ +module Impl { + class Statement extends Generated::Statement { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/StaticFieldConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/StaticFieldConstructor.qll new file mode 100644 index 000000000000..d2991b311830 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/StaticFieldConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `StaticField` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `StaticField` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructStaticField(Raw::StaticField id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/StaticFieldImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/StaticFieldImpl.qll new file mode 100644 index 000000000000..e26b7fb59e84 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/StaticFieldImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `StaticField`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.StaticField + +/** + * INTERNAL: This module contains the customizable definition of `StaticField` and should not + * be referenced directly. + */ +module Impl { + class StaticField extends Generated::StaticField { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/StaticMethodCallConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/StaticMethodCallConstructor.qll new file mode 100644 index 000000000000..f26e75a3b135 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/StaticMethodCallConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `StaticMethodCall` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `StaticMethodCall` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructStaticMethodCall(Raw::StaticMethodCall id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/StaticMethodCallImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/StaticMethodCallImpl.qll new file mode 100644 index 000000000000..54d97adc6906 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/StaticMethodCallImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `StaticMethodCall`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.StaticMethodCall + +/** + * INTERNAL: This module contains the customizable definition of `StaticMethodCall` and should not + * be referenced directly. + */ +module Impl { + class StaticMethodCall extends Generated::StaticMethodCall { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/StaticQualifierConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/StaticQualifierConstructor.qll new file mode 100644 index 000000000000..090440f3adeb --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/StaticQualifierConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `StaticQualifier` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `StaticQualifier` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructStaticQualifier(Raw::StaticQualifier id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/StaticQualifierImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/StaticQualifierImpl.qll new file mode 100644 index 000000000000..8a67fb408f5d --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/StaticQualifierImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `StaticQualifier`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.StaticQualifier + +/** + * INTERNAL: This module contains the customizable definition of `StaticQualifier` and should not + * be referenced directly. + */ +module Impl { + class StaticQualifier extends Generated::StaticQualifier { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/StringAttributeLiteralConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/StringAttributeLiteralConstructor.qll new file mode 100644 index 000000000000..3754b4a8c2de --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/StringAttributeLiteralConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `StringAttributeLiteral` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `StringAttributeLiteral` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructStringAttributeLiteral(Raw::StringAttributeLiteral id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/StringAttributeLiteralImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/StringAttributeLiteralImpl.qll new file mode 100644 index 000000000000..97d2d8c09d68 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/StringAttributeLiteralImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `StringAttributeLiteral`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.StringAttributeLiteral + +/** + * INTERNAL: This module contains the customizable definition of `StringAttributeLiteral` and should not + * be referenced directly. + */ +module Impl { + class StringAttributeLiteral extends Generated::StringAttributeLiteral { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/StringLengthTypeConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/StringLengthTypeConstructor.qll new file mode 100644 index 000000000000..32e74c119a61 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/StringLengthTypeConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `StringLengthType` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `StringLengthType` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructStringLengthType(Raw::StringLengthType id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/StringLengthTypeImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/StringLengthTypeImpl.qll new file mode 100644 index 000000000000..7ce4ec4277f1 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/StringLengthTypeImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `StringLengthType`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.StringLengthType + +/** + * INTERNAL: This module contains the customizable definition of `StringLengthType` and should not + * be referenced directly. + */ +module Impl { + class StringLengthType extends Generated::StringLengthType { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/StringLiteralExpressionConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/StringLiteralExpressionConstructor.qll new file mode 100644 index 000000000000..0f9a1489ad3f --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/StringLiteralExpressionConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `StringLiteralExpression` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `StringLiteralExpression` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructStringLiteralExpression(Raw::StringLiteralExpression id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/StringLiteralExpressionImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/StringLiteralExpressionImpl.qll new file mode 100644 index 000000000000..e80829cb7223 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/StringLiteralExpressionImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `StringLiteralExpression`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.StringLiteralExpression + +/** + * INTERNAL: This module contains the customizable definition of `StringLiteralExpression` and should not + * be referenced directly. + */ +module Impl { + class StringLiteralExpression extends Generated::StringLiteralExpression { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/StringTypeImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/StringTypeImpl.qll new file mode 100644 index 000000000000..30c6724cd8fd --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/StringTypeImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `StringType`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.StringType + +/** + * INTERNAL: This module contains the customizable definition of `StringType` and should not + * be referenced directly. + */ +module Impl { + class StringType extends Generated::StringType { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/StringTypeInternalConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/StringTypeInternalConstructor.qll new file mode 100644 index 000000000000..24990ba8678e --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/StringTypeInternalConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `StringTypeInternal` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `StringTypeInternal` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructStringTypeInternal(Raw::StringTypeInternal id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/StringTypeInternalImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/StringTypeInternalImpl.qll new file mode 100644 index 000000000000..cd516bafb32a --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/StringTypeInternalImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `StringTypeInternal`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.StringTypeInternal + +/** + * INTERNAL: This module contains the customizable definition of `StringTypeInternal` and should not + * be referenced directly. + */ +module Impl { + class StringTypeInternal extends Generated::StringTypeInternal { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/SubtractExpressionConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/SubtractExpressionConstructor.qll new file mode 100644 index 000000000000..4b0242795c88 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/SubtractExpressionConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `SubtractExpression` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `SubtractExpression` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructSubtractExpression(Raw::SubtractExpression id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/SubtractExpressionImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/SubtractExpressionImpl.qll new file mode 100644 index 000000000000..cba04f6e5abc --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/SubtractExpressionImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `SubtractExpression`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.SubtractExpression + +/** + * INTERNAL: This module contains the customizable definition of `SubtractExpression` and should not + * be referenced directly. + */ +module Impl { + class SubtractExpression extends Generated::SubtractExpression { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/SumAggregateSelectionConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/SumAggregateSelectionConstructor.qll new file mode 100644 index 000000000000..0db6a0d643b9 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/SumAggregateSelectionConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `SumAggregateSelection` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `SumAggregateSelection` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructSumAggregateSelection(Raw::SumAggregateSelection id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/SumAggregateSelectionImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/SumAggregateSelectionImpl.qll new file mode 100644 index 000000000000..bedf31ea9f1e --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/SumAggregateSelectionImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `SumAggregateSelection`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.SumAggregateSelection + +/** + * INTERNAL: This module contains the customizable definition of `SumAggregateSelection` and should not + * be referenced directly. + */ +module Impl { + class SumAggregateSelection extends Generated::SumAggregateSelection { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/SuperCallConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/SuperCallConstructor.qll new file mode 100644 index 000000000000..bbb1e6c91180 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/SuperCallConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `SuperCall` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `SuperCall` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructSuperCall(Raw::SuperCall id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/SuperCallImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/SuperCallImpl.qll new file mode 100644 index 000000000000..b0a5c8825c29 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/SuperCallImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `SuperCall`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.SuperCall + +/** + * INTERNAL: This module contains the customizable definition of `SuperCall` and should not + * be referenced directly. + */ +module Impl { + class SuperCall extends Generated::SuperCall { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/SwitchCaseConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/SwitchCaseConstructor.qll new file mode 100644 index 000000000000..bc9c3c648dfd --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/SwitchCaseConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `SwitchCase` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `SwitchCase` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructSwitchCase(Raw::SwitchCase id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/SwitchCaseImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/SwitchCaseImpl.qll new file mode 100644 index 000000000000..ebe7467f4319 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/SwitchCaseImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `SwitchCase`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.SwitchCase + +/** + * INTERNAL: This module contains the customizable definition of `SwitchCase` and should not + * be referenced directly. + */ +module Impl { + class SwitchCase extends Generated::SwitchCase { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/SwitchStatementCaseEntryConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/SwitchStatementCaseEntryConstructor.qll new file mode 100644 index 000000000000..17636e574f15 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/SwitchStatementCaseEntryConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `SwitchStatementCaseEntry` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `SwitchStatementCaseEntry` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructSwitchStatementCaseEntry(Raw::SwitchStatementCaseEntry id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/SwitchStatementCaseEntryImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/SwitchStatementCaseEntryImpl.qll new file mode 100644 index 000000000000..e8a35860068c --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/SwitchStatementCaseEntryImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `SwitchStatementCaseEntry`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.SwitchStatementCaseEntry + +/** + * INTERNAL: This module contains the customizable definition of `SwitchStatementCaseEntry` and should not + * be referenced directly. + */ +module Impl { + class SwitchStatementCaseEntry extends Generated::SwitchStatementCaseEntry { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/SwitchStatementConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/SwitchStatementConstructor.qll new file mode 100644 index 000000000000..e5a0579431c8 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/SwitchStatementConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `SwitchStatement` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `SwitchStatement` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructSwitchStatement(Raw::SwitchStatement id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/SwitchStatementImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/SwitchStatementImpl.qll new file mode 100644 index 000000000000..d4c7162cbb58 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/SwitchStatementImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `SwitchStatement`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.SwitchStatement + +/** + * INTERNAL: This module contains the customizable definition of `SwitchStatement` and should not + * be referenced directly. + */ +module Impl { + class SwitchStatement extends Generated::SwitchStatement { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/TableConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/TableConstructor.qll new file mode 100644 index 000000000000..45a6dbcd95a3 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/TableConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `Table` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `Table` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructTable(Raw::Table id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/TableFieldDeclarationConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/TableFieldDeclarationConstructor.qll new file mode 100644 index 000000000000..dab617e9260d --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/TableFieldDeclarationConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `TableFieldDeclaration` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `TableFieldDeclaration` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructTableFieldDeclaration(Raw::TableFieldDeclaration id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/TableFieldDeclarationImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/TableFieldDeclarationImpl.qll new file mode 100644 index 000000000000..59c114527d62 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/TableFieldDeclarationImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `TableFieldDeclaration`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.TableFieldDeclaration + +/** + * INTERNAL: This module contains the customizable definition of `TableFieldDeclaration` and should not + * be referenced directly. + */ +module Impl { + class TableFieldDeclaration extends Generated::TableFieldDeclaration { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/TableFieldReferenceImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/TableFieldReferenceImpl.qll new file mode 100644 index 000000000000..cacb60fc91fc --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/TableFieldReferenceImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `TableFieldReference`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.TableFieldReference + +/** + * INTERNAL: This module contains the customizable definition of `TableFieldReference` and should not + * be referenced directly. + */ +module Impl { + class TableFieldReference extends Generated::TableFieldReference { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/TableImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/TableImpl.qll new file mode 100644 index 000000000000..2526d02b5c78 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/TableImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `Table`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Table + +/** + * INTERNAL: This module contains the customizable definition of `Table` and should not + * be referenced directly. + */ +module Impl { + class Table extends Generated::Table { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/TableLookupExpressionConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/TableLookupExpressionConstructor.qll new file mode 100644 index 000000000000..bc870f0449f1 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/TableLookupExpressionConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `TableLookupExpression` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `TableLookupExpression` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructTableLookupExpression(Raw::TableLookupExpression id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/TableLookupExpressionImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/TableLookupExpressionImpl.qll new file mode 100644 index 000000000000..c528a6d95ba5 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/TableLookupExpressionImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `TableLookupExpression`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.TableLookupExpression + +/** + * INTERNAL: This module contains the customizable definition of `TableLookupExpression` and should not + * be referenced directly. + */ +module Impl { + class TableLookupExpression extends Generated::TableLookupExpression { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/ThrowStatementConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/ThrowStatementConstructor.qll new file mode 100644 index 000000000000..58e9d13d96d8 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/ThrowStatementConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `ThrowStatement` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `ThrowStatement` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructThrowStatement(Raw::ThrowStatement id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/ThrowStatementImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/ThrowStatementImpl.qll new file mode 100644 index 000000000000..fa9854f8cb2e --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/ThrowStatementImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `ThrowStatement`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.ThrowStatement + +/** + * INTERNAL: This module contains the customizable definition of `ThrowStatement` and should not + * be referenced directly. + */ +module Impl { + class ThrowStatement extends Generated::ThrowStatement { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/TryStatementCatchEntryConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/TryStatementCatchEntryConstructor.qll new file mode 100644 index 000000000000..5b0b22ca709b --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/TryStatementCatchEntryConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `TryStatementCatchEntry` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `TryStatementCatchEntry` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructTryStatementCatchEntry(Raw::TryStatementCatchEntry id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/TryStatementCatchEntryImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/TryStatementCatchEntryImpl.qll new file mode 100644 index 000000000000..db98372f2087 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/TryStatementCatchEntryImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `TryStatementCatchEntry`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.TryStatementCatchEntry + +/** + * INTERNAL: This module contains the customizable definition of `TryStatementCatchEntry` and should not + * be referenced directly. + */ +module Impl { + class TryStatementCatchEntry extends Generated::TryStatementCatchEntry { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/TryStatementConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/TryStatementConstructor.qll new file mode 100644 index 000000000000..16ceae0b864d --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/TryStatementConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `TryStatement` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `TryStatement` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructTryStatement(Raw::TryStatement id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/TryStatementImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/TryStatementImpl.qll new file mode 100644 index 000000000000..abe35c16966e --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/TryStatementImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `TryStatement`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.TryStatement + +/** + * INTERNAL: This module contains the customizable definition of `TryStatement` and should not + * be referenced directly. + */ +module Impl { + class TryStatement extends Generated::TryStatement { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/TtsAbortStatementConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/TtsAbortStatementConstructor.qll new file mode 100644 index 000000000000..ab94243c11af --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/TtsAbortStatementConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `TtsAbortStatement` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `TtsAbortStatement` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructTtsAbortStatement(Raw::TtsAbortStatement id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/TtsAbortStatementImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/TtsAbortStatementImpl.qll new file mode 100644 index 000000000000..fe020fc078e9 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/TtsAbortStatementImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `TtsAbortStatement`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.TtsAbortStatement + +/** + * INTERNAL: This module contains the customizable definition of `TtsAbortStatement` and should not + * be referenced directly. + */ +module Impl { + class TtsAbortStatement extends Generated::TtsAbortStatement { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/TtsBeginStatementConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/TtsBeginStatementConstructor.qll new file mode 100644 index 000000000000..7ac2e6e15bfd --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/TtsBeginStatementConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `TtsBeginStatement` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `TtsBeginStatement` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructTtsBeginStatement(Raw::TtsBeginStatement id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/TtsBeginStatementImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/TtsBeginStatementImpl.qll new file mode 100644 index 000000000000..8a769a0f49fe --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/TtsBeginStatementImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `TtsBeginStatement`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.TtsBeginStatement + +/** + * INTERNAL: This module contains the customizable definition of `TtsBeginStatement` and should not + * be referenced directly. + */ +module Impl { + class TtsBeginStatement extends Generated::TtsBeginStatement { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/TtsEndStatementConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/TtsEndStatementConstructor.qll new file mode 100644 index 000000000000..718558fca072 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/TtsEndStatementConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `TtsEndStatement` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `TtsEndStatement` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructTtsEndStatement(Raw::TtsEndStatement id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/TtsEndStatementImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/TtsEndStatementImpl.qll new file mode 100644 index 000000000000..8784c562b1eb --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/TtsEndStatementImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `TtsEndStatement`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.TtsEndStatement + +/** + * INTERNAL: This module contains the customizable definition of `TtsEndStatement` and should not + * be referenced directly. + */ +module Impl { + class TtsEndStatement extends Generated::TtsEndStatement { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/TtsStatementImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/TtsStatementImpl.qll new file mode 100644 index 000000000000..facb3a53ea09 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/TtsStatementImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `TtsStatement`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.TtsStatement + +/** + * INTERNAL: This module contains the customizable definition of `TtsStatement` and should not + * be referenced directly. + */ +module Impl { + class TtsStatement extends Generated::TtsStatement { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/UnaryExpressionImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/UnaryExpressionImpl.qll new file mode 100644 index 000000000000..896b68e3cd4d --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/UnaryExpressionImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `UnaryExpression`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.UnaryExpression + +/** + * INTERNAL: This module contains the customizable definition of `UnaryExpression` and should not + * be referenced directly. + */ +module Impl { + class UnaryExpression extends Generated::UnaryExpression { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/UnaryMinusExpressionConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/UnaryMinusExpressionConstructor.qll new file mode 100644 index 000000000000..86a9bceb4a05 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/UnaryMinusExpressionConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `UnaryMinusExpression` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `UnaryMinusExpression` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructUnaryMinusExpression(Raw::UnaryMinusExpression id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/UnaryMinusExpressionImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/UnaryMinusExpressionImpl.qll new file mode 100644 index 000000000000..e30fe1c808e4 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/UnaryMinusExpressionImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `UnaryMinusExpression`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.UnaryMinusExpression + +/** + * INTERNAL: This module contains the customizable definition of `UnaryMinusExpression` and should not + * be referenced directly. + */ +module Impl { + class UnaryMinusExpression extends Generated::UnaryMinusExpression { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/UncheckedStatementConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/UncheckedStatementConstructor.qll new file mode 100644 index 000000000000..191dc636487c --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/UncheckedStatementConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `UncheckedStatement` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `UncheckedStatement` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructUncheckedStatement(Raw::UncheckedStatement id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/UncheckedStatementImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/UncheckedStatementImpl.qll new file mode 100644 index 000000000000..6ced4fc03970 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/UncheckedStatementImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `UncheckedStatement`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.UncheckedStatement + +/** + * INTERNAL: This module contains the customizable definition of `UncheckedStatement` and should not + * be referenced directly. + */ +module Impl { + class UncheckedStatement extends Generated::UncheckedStatement { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/UnspecifiedElementConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/UnspecifiedElementConstructor.qll new file mode 100644 index 000000000000..337adf0d0dd1 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/UnspecifiedElementConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `UnspecifiedElement` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `UnspecifiedElement` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructUnspecifiedElement(Raw::UnspecifiedElement id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/UnspecifiedElementImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/UnspecifiedElementImpl.qll new file mode 100644 index 000000000000..640d8ede0222 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/UnspecifiedElementImpl.qll @@ -0,0 +1,19 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `UnspecifiedElement`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.UnspecifiedElement + +/** + * INTERNAL: This module contains the customizable definition of `UnspecifiedElement` and should not + * be referenced directly. + */ +module Impl { + /** + * A node that could not be extracted, for example because of a syntax error. + */ + class UnspecifiedElement extends Generated::UnspecifiedElement { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/UpdateStatementConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/UpdateStatementConstructor.qll new file mode 100644 index 000000000000..c0115ea72296 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/UpdateStatementConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `UpdateStatement` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `UpdateStatement` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructUpdateStatement(Raw::UpdateStatement id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/UpdateStatementImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/UpdateStatementImpl.qll new file mode 100644 index 000000000000..b3465531ba69 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/UpdateStatementImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `UpdateStatement`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.UpdateStatement + +/** + * INTERNAL: This module contains the customizable definition of `UpdateStatement` and should not + * be referenced directly. + */ +module Impl { + class UpdateStatement extends Generated::UpdateStatement { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/UsingStatementConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/UsingStatementConstructor.qll new file mode 100644 index 000000000000..c54aa017eb7c --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/UsingStatementConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `UsingStatement` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `UsingStatement` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructUsingStatement(Raw::UsingStatement id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/UsingStatementImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/UsingStatementImpl.qll new file mode 100644 index 000000000000..019235253b31 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/UsingStatementImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `UsingStatement`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.UsingStatement + +/** + * INTERNAL: This module contains the customizable definition of `UsingStatement` and should not + * be referenced directly. + */ +module Impl { + class UsingStatement extends Generated::UsingStatement { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/ValidTimeStateDateConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/ValidTimeStateDateConstructor.qll new file mode 100644 index 000000000000..ebc6cc81c60f --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/ValidTimeStateDateConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `ValidTimeStateDate` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `ValidTimeStateDate` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructValidTimeStateDate(Raw::ValidTimeStateDate id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/ValidTimeStateDateImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/ValidTimeStateDateImpl.qll new file mode 100644 index 000000000000..8096ce579a05 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/ValidTimeStateDateImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `ValidTimeStateDate`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.ValidTimeStateDate + +/** + * INTERNAL: This module contains the customizable definition of `ValidTimeStateDate` and should not + * be referenced directly. + */ +module Impl { + class ValidTimeStateDate extends Generated::ValidTimeStateDate { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/ValidTimeStateImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/ValidTimeStateImpl.qll new file mode 100644 index 000000000000..d477790f29c0 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/ValidTimeStateImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `ValidTimeState`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.ValidTimeState + +/** + * INTERNAL: This module contains the customizable definition of `ValidTimeState` and should not + * be referenced directly. + */ +module Impl { + class ValidTimeState extends Generated::ValidTimeState { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/ValidTimeStateRangeConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/ValidTimeStateRangeConstructor.qll new file mode 100644 index 000000000000..3796f5dfb5b4 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/ValidTimeStateRangeConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `ValidTimeStateRange` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `ValidTimeStateRange` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructValidTimeStateRange(Raw::ValidTimeStateRange id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/ValidTimeStateRangeImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/ValidTimeStateRangeImpl.qll new file mode 100644 index 000000000000..24152de5a679 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/ValidTimeStateRangeImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `ValidTimeStateRange`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.ValidTimeStateRange + +/** + * INTERNAL: This module contains the customizable definition of `ValidTimeStateRange` and should not + * be referenced directly. + */ +module Impl { + class ValidTimeStateRange extends Generated::ValidTimeStateRange { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/VarTypeConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/VarTypeConstructor.qll new file mode 100644 index 000000000000..4e64607bd99d --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/VarTypeConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `VarType` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `VarType` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructVarType(Raw::VarType id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/VarTypeImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/VarTypeImpl.qll new file mode 100644 index 000000000000..b5d7e8090270 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/VarTypeImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `VarType`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.VarType + +/** + * INTERNAL: This module contains the customizable definition of `VarType` and should not + * be referenced directly. + */ +module Impl { + class VarType extends Generated::VarType { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/VariableDeclarationImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/VariableDeclarationImpl.qll new file mode 100644 index 000000000000..7942f09a9d8e --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/VariableDeclarationImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `VariableDeclaration`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.VariableDeclaration + +/** + * INTERNAL: This module contains the customizable definition of `VariableDeclaration` and should not + * be referenced directly. + */ +module Impl { + class VariableDeclaration extends Generated::VariableDeclaration { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/VariableDeclarationInternalConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/VariableDeclarationInternalConstructor.qll new file mode 100644 index 000000000000..b7c8d92ffc13 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/VariableDeclarationInternalConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `VariableDeclarationInternal` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `VariableDeclarationInternal` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructVariableDeclarationInternal(Raw::VariableDeclarationInternal id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/VariableDeclarationInternalImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/VariableDeclarationInternalImpl.qll new file mode 100644 index 000000000000..6350d7b3caf1 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/VariableDeclarationInternalImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `VariableDeclarationInternal`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.VariableDeclarationInternal + +/** + * INTERNAL: This module contains the customizable definition of `VariableDeclarationInternal` and should not + * be referenced directly. + */ +module Impl { + class VariableDeclarationInternal extends Generated::VariableDeclarationInternal { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/VoidTypeConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/VoidTypeConstructor.qll new file mode 100644 index 000000000000..d0c4c0a7a649 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/VoidTypeConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `VoidType` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `VoidType` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructVoidType(Raw::VoidType id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/VoidTypeImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/VoidTypeImpl.qll new file mode 100644 index 000000000000..0add797fa70f --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/VoidTypeImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `VoidType`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.VoidType + +/** + * INTERNAL: This module contains the customizable definition of `VoidType` and should not + * be referenced directly. + */ +module Impl { + class VoidType extends Generated::VoidType { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/WhileStatementConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/WhileStatementConstructor.qll new file mode 100644 index 000000000000..c9c39061fca1 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/WhileStatementConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `WhileStatement` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `WhileStatement` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructWhileStatement(Raw::WhileStatement id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/WhileStatementImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/WhileStatementImpl.qll new file mode 100644 index 000000000000..e2a8c7a7b387 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/WhileStatementImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `WhileStatement`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.WhileStatement + +/** + * INTERNAL: This module contains the customizable definition of `WhileStatement` and should not + * be referenced directly. + */ +module Impl { + class WhileStatement extends Generated::WhileStatement { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/XppTupleImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/XppTupleImpl.qll new file mode 100644 index 000000000000..c5047d9fdc47 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/XppTupleImpl.qll @@ -0,0 +1,23 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `XppTuple`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.XppTuple + +/** + * INTERNAL: This module contains the customizable definition of `XppTuple` and should not + * be referenced directly. + */ +module Impl { + /** + * Base of the classes standing in for tuples in the compiler's AST. + * + * The X++ compiler uses CLR tuples for a handful of grouped values, such as a `catch` + * together with its handler body. The schema has no tuple type, so the generator emits a + * named class per tuple-valued property instead. + */ + class XppTuple extends Generated::XppTuple { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/XppTypeCompilationUnitConstructor.qll b/xpp/ql/lib/codeql/xpp/elements/internal/XppTypeCompilationUnitConstructor.qll new file mode 100644 index 000000000000..887ce9e6e17d --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/XppTypeCompilationUnitConstructor.qll @@ -0,0 +1,14 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module defines the hook used internally to tweak the characteristic predicate of + * `XppTypeCompilationUnit` synthesized instances. + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.Raw + +/** + * The characteristic predicate of `XppTypeCompilationUnit` synthesized instances. + * INTERNAL: Do not use. + */ +predicate constructXppTypeCompilationUnit(Raw::XppTypeCompilationUnit id) { any() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/XppTypeCompilationUnitImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/XppTypeCompilationUnitImpl.qll new file mode 100644 index 000000000000..f8cfdcce19dd --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/XppTypeCompilationUnitImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `XppTypeCompilationUnit`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.XppTypeCompilationUnit + +/** + * INTERNAL: This module contains the customizable definition of `XppTypeCompilationUnit` and should not + * be referenced directly. + */ +module Impl { + class XppTypeCompilationUnit extends Generated::XppTypeCompilationUnit { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/XppTypeImpl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/XppTypeImpl.qll new file mode 100644 index 000000000000..d2a88596377c --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/XppTypeImpl.qll @@ -0,0 +1,16 @@ +// generated by xpp/tools/generate-schema.sh, remove this comment if you wish to edit this file +/** + * This module provides a hand-modifiable wrapper around the generated class `XppType`. + * + * INTERNAL: Do not use. + */ + +private import codeql.xpp.elements.internal.generated.XppType + +/** + * INTERNAL: This module contains the customizable definition of `XppType` and should not + * be referenced directly. + */ +module Impl { + class XppType extends Generated::XppType { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/AddExpression.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/AddExpression.qll new file mode 100644 index 000000000000..fcf2b108bf31 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/AddExpression.qll @@ -0,0 +1,23 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `AddExpression`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.BinaryExpressionImpl::Impl as BinaryExpressionImpl + +/** + * INTERNAL: This module contains the fully generated definition of `AddExpression` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::AddExpression` class directly. + * Use the subclass `AddExpression`, where the following predicates are available. + */ + class AddExpression extends Synth::TAddExpression, BinaryExpressionImpl::BinaryExpression { + override string getAPrimaryQlClass() { result = "AddExpression" } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/AggregateSelection.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/AggregateSelection.qll new file mode 100644 index 000000000000..c3eea56ab2d6 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/AggregateSelection.qll @@ -0,0 +1,22 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `AggregateSelection`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.SelectionFieldImpl::Impl as SelectionFieldImpl + +/** + * INTERNAL: This module contains the fully generated definition of `AggregateSelection` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::AggregateSelection` class directly. + * Use the subclass `AggregateSelection`, where the following predicates are available. + */ + class AggregateSelection extends Synth::TAggregateSelection, SelectionFieldImpl::SelectionField { + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/AllFieldsSelection.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/AllFieldsSelection.qll new file mode 100644 index 000000000000..61aada4e5249 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/AllFieldsSelection.qll @@ -0,0 +1,23 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `AllFieldsSelection`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.SelectionImpl::Impl as SelectionImpl + +/** + * INTERNAL: This module contains the fully generated definition of `AllFieldsSelection` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::AllFieldsSelection` class directly. + * Use the subclass `AllFieldsSelection`, where the following predicates are available. + */ + class AllFieldsSelection extends Synth::TAllFieldsSelection, SelectionImpl::Selection { + override string getAPrimaryQlClass() { result = "AllFieldsSelection" } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/AndExpression.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/AndExpression.qll new file mode 100644 index 000000000000..fc0998259a4b --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/AndExpression.qll @@ -0,0 +1,23 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `AndExpression`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.BinaryExpressionImpl::Impl as BinaryExpressionImpl + +/** + * INTERNAL: This module contains the fully generated definition of `AndExpression` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::AndExpression` class directly. + * Use the subclass `AndExpression`, where the following predicates are available. + */ + class AndExpression extends Synth::TAndExpression, BinaryExpressionImpl::BinaryExpression { + override string getAPrimaryQlClass() { result = "AndExpression" } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/AnyType.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/AnyType.qll new file mode 100644 index 000000000000..ba55147098a2 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/AnyType.qll @@ -0,0 +1,23 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `AnyType`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.XppTypeImpl::Impl as XppTypeImpl + +/** + * INTERNAL: This module contains the fully generated definition of `AnyType` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::AnyType` class directly. + * Use the subclass `AnyType`, where the following predicates are available. + */ + class AnyType extends Synth::TAnyType, XppTypeImpl::XppType { + override string getAPrimaryQlClass() { result = "AnyType" } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/ArraySpecification.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/ArraySpecification.qll new file mode 100644 index 000000000000..a1745240a06c --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/ArraySpecification.qll @@ -0,0 +1,54 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `ArraySpecification`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.AstImpl::Impl as AstImpl +import codeql.xpp.elements.Expression + +/** + * INTERNAL: This module contains the fully generated definition of `ArraySpecification` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::ArraySpecification` class directly. + * Use the subclass `ArraySpecification`, where the following predicates are available. + */ + class ArraySpecification extends Synth::TArraySpecification, AstImpl::Ast { + override string getAPrimaryQlClass() { result = "ArraySpecification" } + + /** + * Gets the index1 of this array specification, if it exists. + */ + Expression getIndex1() { + result = + Synth::convertExpressionFromRaw(Synth::convertArraySpecificationToRaw(this) + .(Raw::ArraySpecification) + .getIndex1()) + } + + /** + * Holds if `getIndex1()` exists. + */ + final predicate hasIndex1() { exists(this.getIndex1()) } + + /** + * Gets the index2 of this array specification, if it exists. + */ + Expression getIndex2() { + result = + Synth::convertExpressionFromRaw(Synth::convertArraySpecificationToRaw(this) + .(Raw::ArraySpecification) + .getIndex2()) + } + + /** + * Holds if `getIndex2()` exists. + */ + final predicate hasIndex2() { exists(this.getIndex2()) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/AsClrExpression.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/AsClrExpression.qll new file mode 100644 index 000000000000..39e58fff4f9a --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/AsClrExpression.qll @@ -0,0 +1,23 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `AsClrExpression`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.IsAsExpressionImpl::Impl as IsAsExpressionImpl + +/** + * INTERNAL: This module contains the fully generated definition of `AsClrExpression` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::AsClrExpression` class directly. + * Use the subclass `AsClrExpression`, where the following predicates are available. + */ + class AsClrExpression extends Synth::TAsClrExpression, IsAsExpressionImpl::IsAsExpression { + override string getAPrimaryQlClass() { result = "AsClrExpression" } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/AsExpression.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/AsExpression.qll new file mode 100644 index 000000000000..c76daecf838a --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/AsExpression.qll @@ -0,0 +1,23 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `AsExpression`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.IsAsExpressionImpl::Impl as IsAsExpressionImpl + +/** + * INTERNAL: This module contains the fully generated definition of `AsExpression` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::AsExpression` class directly. + * Use the subclass `AsExpression`, where the following predicates are available. + */ + class AsExpression extends Synth::TAsExpression, IsAsExpressionImpl::IsAsExpression { + override string getAPrimaryQlClass() { result = "AsExpression" } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/AssignDecrementStatement.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/AssignDecrementStatement.qll new file mode 100644 index 000000000000..c41dddb1ede6 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/AssignDecrementStatement.qll @@ -0,0 +1,25 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `AssignDecrementStatement`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.AssignmentBinaryImpl::Impl as AssignmentBinaryImpl + +/** + * INTERNAL: This module contains the fully generated definition of `AssignDecrementStatement` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::AssignDecrementStatement` class directly. + * Use the subclass `AssignDecrementStatement`, where the following predicates are available. + */ + class AssignDecrementStatement extends Synth::TAssignDecrementStatement, + AssignmentBinaryImpl::AssignmentBinary + { + override string getAPrimaryQlClass() { result = "AssignDecrementStatement" } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/AssignDivideStatement.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/AssignDivideStatement.qll new file mode 100644 index 000000000000..27c3a13bf7be --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/AssignDivideStatement.qll @@ -0,0 +1,25 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `AssignDivideStatement`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.AssignmentBinaryImpl::Impl as AssignmentBinaryImpl + +/** + * INTERNAL: This module contains the fully generated definition of `AssignDivideStatement` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::AssignDivideStatement` class directly. + * Use the subclass `AssignDivideStatement`, where the following predicates are available. + */ + class AssignDivideStatement extends Synth::TAssignDivideStatement, + AssignmentBinaryImpl::AssignmentBinary + { + override string getAPrimaryQlClass() { result = "AssignDivideStatement" } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/AssignEqualStatement.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/AssignEqualStatement.qll new file mode 100644 index 000000000000..8c5df37b45c5 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/AssignEqualStatement.qll @@ -0,0 +1,25 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `AssignEqualStatement`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.AssignmentBinaryImpl::Impl as AssignmentBinaryImpl + +/** + * INTERNAL: This module contains the fully generated definition of `AssignEqualStatement` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::AssignEqualStatement` class directly. + * Use the subclass `AssignEqualStatement`, where the following predicates are available. + */ + class AssignEqualStatement extends Synth::TAssignEqualStatement, + AssignmentBinaryImpl::AssignmentBinary + { + override string getAPrimaryQlClass() { result = "AssignEqualStatement" } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/AssignIncrementStatement.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/AssignIncrementStatement.qll new file mode 100644 index 000000000000..e63ee1ffab3c --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/AssignIncrementStatement.qll @@ -0,0 +1,25 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `AssignIncrementStatement`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.AssignmentBinaryImpl::Impl as AssignmentBinaryImpl + +/** + * INTERNAL: This module contains the fully generated definition of `AssignIncrementStatement` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::AssignIncrementStatement` class directly. + * Use the subclass `AssignIncrementStatement`, where the following predicates are available. + */ + class AssignIncrementStatement extends Synth::TAssignIncrementStatement, + AssignmentBinaryImpl::AssignmentBinary + { + override string getAPrimaryQlClass() { result = "AssignIncrementStatement" } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/AssignMultipleFieldStatement.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/AssignMultipleFieldStatement.qll new file mode 100644 index 000000000000..e6c65841fb21 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/AssignMultipleFieldStatement.qll @@ -0,0 +1,62 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `AssignMultipleFieldStatement`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.AssignmentStatementImpl::Impl as AssignmentStatementImpl +import codeql.xpp.elements.Expression +import codeql.xpp.elements.FieldSpecification + +/** + * INTERNAL: This module contains the fully generated definition of `AssignMultipleFieldStatement` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::AssignMultipleFieldStatement` class directly. + * Use the subclass `AssignMultipleFieldStatement`, where the following predicates are available. + */ + class AssignMultipleFieldStatement extends Synth::TAssignMultipleFieldStatement, + AssignmentStatementImpl::AssignmentStatement + { + override string getAPrimaryQlClass() { result = "AssignMultipleFieldStatement" } + + /** + * Gets the expression of this assign multiple field statement, if it exists. + */ + Expression getExpression() { + result = + Synth::convertExpressionFromRaw(Synth::convertAssignMultipleFieldStatementToRaw(this) + .(Raw::AssignMultipleFieldStatement) + .getExpression()) + } + + /** + * Holds if `getExpression()` exists. + */ + final predicate hasExpression() { exists(this.getExpression()) } + + /** + * Gets the `index`th field of this assign multiple field statement (0-based). + */ + FieldSpecification getField(int index) { + result = + Synth::convertFieldSpecificationFromRaw(Synth::convertAssignMultipleFieldStatementToRaw(this) + .(Raw::AssignMultipleFieldStatement) + .getField(index)) + } + + /** + * Gets any of the fields of this assign multiple field statement. + */ + final FieldSpecification getAField() { result = this.getField(_) } + + /** + * Gets the number of fields of this assign multiple field statement. + */ + final int getNumberOfFields() { result = count(int i | exists(this.getField(i))) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/AssignMultiplyStatement.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/AssignMultiplyStatement.qll new file mode 100644 index 000000000000..354ea78a771f --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/AssignMultiplyStatement.qll @@ -0,0 +1,25 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `AssignMultiplyStatement`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.AssignmentBinaryImpl::Impl as AssignmentBinaryImpl + +/** + * INTERNAL: This module contains the fully generated definition of `AssignMultiplyStatement` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::AssignMultiplyStatement` class directly. + * Use the subclass `AssignMultiplyStatement`, where the following predicates are available. + */ + class AssignMultiplyStatement extends Synth::TAssignMultiplyStatement, + AssignmentBinaryImpl::AssignmentBinary + { + override string getAPrimaryQlClass() { result = "AssignMultiplyStatement" } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/AssignPostDecrementStatement.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/AssignPostDecrementStatement.qll new file mode 100644 index 000000000000..df397e65e66e --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/AssignPostDecrementStatement.qll @@ -0,0 +1,25 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `AssignPostDecrementStatement`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.AssignmentSingleFieldImpl::Impl as AssignmentSingleFieldImpl + +/** + * INTERNAL: This module contains the fully generated definition of `AssignPostDecrementStatement` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::AssignPostDecrementStatement` class directly. + * Use the subclass `AssignPostDecrementStatement`, where the following predicates are available. + */ + class AssignPostDecrementStatement extends Synth::TAssignPostDecrementStatement, + AssignmentSingleFieldImpl::AssignmentSingleField + { + override string getAPrimaryQlClass() { result = "AssignPostDecrementStatement" } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/AssignPostIncrementStatement.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/AssignPostIncrementStatement.qll new file mode 100644 index 000000000000..18ef0d681479 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/AssignPostIncrementStatement.qll @@ -0,0 +1,25 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `AssignPostIncrementStatement`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.AssignmentSingleFieldImpl::Impl as AssignmentSingleFieldImpl + +/** + * INTERNAL: This module contains the fully generated definition of `AssignPostIncrementStatement` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::AssignPostIncrementStatement` class directly. + * Use the subclass `AssignPostIncrementStatement`, where the following predicates are available. + */ + class AssignPostIncrementStatement extends Synth::TAssignPostIncrementStatement, + AssignmentSingleFieldImpl::AssignmentSingleField + { + override string getAPrimaryQlClass() { result = "AssignPostIncrementStatement" } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/AssignPreDecrementStatement.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/AssignPreDecrementStatement.qll new file mode 100644 index 000000000000..ba7030c86862 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/AssignPreDecrementStatement.qll @@ -0,0 +1,25 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `AssignPreDecrementStatement`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.AssignmentSingleFieldImpl::Impl as AssignmentSingleFieldImpl + +/** + * INTERNAL: This module contains the fully generated definition of `AssignPreDecrementStatement` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::AssignPreDecrementStatement` class directly. + * Use the subclass `AssignPreDecrementStatement`, where the following predicates are available. + */ + class AssignPreDecrementStatement extends Synth::TAssignPreDecrementStatement, + AssignmentSingleFieldImpl::AssignmentSingleField + { + override string getAPrimaryQlClass() { result = "AssignPreDecrementStatement" } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/AssignPreIncrementStatement.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/AssignPreIncrementStatement.qll new file mode 100644 index 000000000000..b44e42e50bc5 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/AssignPreIncrementStatement.qll @@ -0,0 +1,25 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `AssignPreIncrementStatement`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.AssignmentSingleFieldImpl::Impl as AssignmentSingleFieldImpl + +/** + * INTERNAL: This module contains the fully generated definition of `AssignPreIncrementStatement` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::AssignPreIncrementStatement` class directly. + * Use the subclass `AssignPreIncrementStatement`, where the following predicates are available. + */ + class AssignPreIncrementStatement extends Synth::TAssignPreIncrementStatement, + AssignmentSingleFieldImpl::AssignmentSingleField + { + override string getAPrimaryQlClass() { result = "AssignPreIncrementStatement" } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/AssignmentBinary.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/AssignmentBinary.qll new file mode 100644 index 000000000000..53df99fa9c17 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/AssignmentBinary.qll @@ -0,0 +1,39 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `AssignmentBinary`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.AssignmentSingleFieldImpl::Impl as AssignmentSingleFieldImpl +import codeql.xpp.elements.Expression + +/** + * INTERNAL: This module contains the fully generated definition of `AssignmentBinary` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::AssignmentBinary` class directly. + * Use the subclass `AssignmentBinary`, where the following predicates are available. + */ + class AssignmentBinary extends Synth::TAssignmentBinary, + AssignmentSingleFieldImpl::AssignmentSingleField + { + /** + * Gets the expression of this assignment binary, if it exists. + */ + Expression getExpression() { + result = + Synth::convertExpressionFromRaw(Synth::convertAssignmentBinaryToRaw(this) + .(Raw::AssignmentBinary) + .getExpression()) + } + + /** + * Holds if `getExpression()` exists. + */ + final predicate hasExpression() { exists(this.getExpression()) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/AssignmentEventHandlerBase.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/AssignmentEventHandlerBase.qll new file mode 100644 index 000000000000..1ca51262b371 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/AssignmentEventHandlerBase.qll @@ -0,0 +1,47 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `AssignmentEventHandlerBase`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.AssignmentSingleFieldImpl::Impl as AssignmentSingleFieldImpl + +/** + * INTERNAL: This module contains the fully generated definition of `AssignmentEventHandlerBase` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::AssignmentEventHandlerBase` class directly. + * Use the subclass `AssignmentEventHandlerBase`, where the following predicates are available. + */ + class AssignmentEventHandlerBase extends Synth::TAssignmentEventHandlerBase, + AssignmentSingleFieldImpl::AssignmentSingleField + { + /** + * Holds if this assignment event handler base addition. + */ + predicate addition() { + Synth::convertAssignmentEventHandlerBaseToRaw(this) + .(Raw::AssignmentEventHandlerBase) + .addition() + } + + /** + * Gets the name of this assignment event handler base, if it exists. + */ + string getName() { + result = + Synth::convertAssignmentEventHandlerBaseToRaw(this) + .(Raw::AssignmentEventHandlerBase) + .getName() + } + + /** + * Holds if `getName()` exists. + */ + final predicate hasName() { exists(this.getName()) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/AssignmentEventHandlerClr.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/AssignmentEventHandlerClr.qll new file mode 100644 index 000000000000..108612d563b6 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/AssignmentEventHandlerClr.qll @@ -0,0 +1,25 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `AssignmentEventHandlerClr`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.AssignmentEventHandlerStaticImpl::Impl as AssignmentEventHandlerStaticImpl + +/** + * INTERNAL: This module contains the fully generated definition of `AssignmentEventHandlerClr` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::AssignmentEventHandlerClr` class directly. + * Use the subclass `AssignmentEventHandlerClr`, where the following predicates are available. + */ + class AssignmentEventHandlerClr extends Synth::TAssignmentEventHandlerClr, + AssignmentEventHandlerStaticImpl::AssignmentEventHandlerStatic + { + override string getAPrimaryQlClass() { result = "AssignmentEventHandlerClr" } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/AssignmentEventHandlerInstance.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/AssignmentEventHandlerInstance.qll new file mode 100644 index 000000000000..c20dfffb3798 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/AssignmentEventHandlerInstance.qll @@ -0,0 +1,41 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `AssignmentEventHandlerInstance`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.AssignmentEventHandlerBaseImpl::Impl as AssignmentEventHandlerBaseImpl +import codeql.xpp.elements.Qualifier + +/** + * INTERNAL: This module contains the fully generated definition of `AssignmentEventHandlerInstance` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::AssignmentEventHandlerInstance` class directly. + * Use the subclass `AssignmentEventHandlerInstance`, where the following predicates are available. + */ + class AssignmentEventHandlerInstance extends Synth::TAssignmentEventHandlerInstance, + AssignmentEventHandlerBaseImpl::AssignmentEventHandlerBase + { + override string getAPrimaryQlClass() { result = "AssignmentEventHandlerInstance" } + + /** + * Gets the qualifier part of this assignment event handler instance, if it exists. + */ + Qualifier getQualifierPart() { + result = + Synth::convertQualifierFromRaw(Synth::convertAssignmentEventHandlerInstanceToRaw(this) + .(Raw::AssignmentEventHandlerInstance) + .getQualifierPart()) + } + + /** + * Holds if `getQualifierPart()` exists. + */ + final predicate hasQualifierPart() { exists(this.getQualifierPart()) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/AssignmentEventHandlerStatic.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/AssignmentEventHandlerStatic.qll new file mode 100644 index 000000000000..c048de7dd45f --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/AssignmentEventHandlerStatic.qll @@ -0,0 +1,38 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `AssignmentEventHandlerStatic`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.AssignmentEventHandlerBaseImpl::Impl as AssignmentEventHandlerBaseImpl + +/** + * INTERNAL: This module contains the fully generated definition of `AssignmentEventHandlerStatic` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::AssignmentEventHandlerStatic` class directly. + * Use the subclass `AssignmentEventHandlerStatic`, where the following predicates are available. + */ + class AssignmentEventHandlerStatic extends Synth::TAssignmentEventHandlerStatic, + AssignmentEventHandlerBaseImpl::AssignmentEventHandlerBase + { + /** + * Gets the type name of this assignment event handler static, if it exists. + */ + string getTypeName() { + result = + Synth::convertAssignmentEventHandlerStaticToRaw(this) + .(Raw::AssignmentEventHandlerStatic) + .getTypeName() + } + + /** + * Holds if `getTypeName()` exists. + */ + final predicate hasTypeName() { exists(this.getTypeName()) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/AssignmentEventHandlerStaticInternal.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/AssignmentEventHandlerStaticInternal.qll new file mode 100644 index 000000000000..496c691b7920 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/AssignmentEventHandlerStaticInternal.qll @@ -0,0 +1,25 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `AssignmentEventHandlerStaticInternal`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.AssignmentEventHandlerStaticImpl::Impl as AssignmentEventHandlerStaticImpl + +/** + * INTERNAL: This module contains the fully generated definition of `AssignmentEventHandlerStaticInternal` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::AssignmentEventHandlerStaticInternal` class directly. + * Use the subclass `AssignmentEventHandlerStaticInternal`, where the following predicates are available. + */ + class AssignmentEventHandlerStaticInternal extends Synth::TAssignmentEventHandlerStaticInternal, + AssignmentEventHandlerStaticImpl::AssignmentEventHandlerStatic + { + override string getAPrimaryQlClass() { result = "AssignmentEventHandlerStaticInternal" } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/AssignmentSingleField.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/AssignmentSingleField.qll new file mode 100644 index 000000000000..2f1ba62a5139 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/AssignmentSingleField.qll @@ -0,0 +1,39 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `AssignmentSingleField`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.AssignmentStatementImpl::Impl as AssignmentStatementImpl +import codeql.xpp.elements.FieldSpecification + +/** + * INTERNAL: This module contains the fully generated definition of `AssignmentSingleField` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::AssignmentSingleField` class directly. + * Use the subclass `AssignmentSingleField`, where the following predicates are available. + */ + class AssignmentSingleField extends Synth::TAssignmentSingleField, + AssignmentStatementImpl::AssignmentStatement + { + /** + * Gets the field of this assignment single field, if it exists. + */ + FieldSpecification getField() { + result = + Synth::convertFieldSpecificationFromRaw(Synth::convertAssignmentSingleFieldToRaw(this) + .(Raw::AssignmentSingleField) + .getField()) + } + + /** + * Holds if `getField()` exists. + */ + final predicate hasField() { exists(this.getField()) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/AssignmentStatement.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/AssignmentStatement.qll new file mode 100644 index 000000000000..2ab4b4004ba4 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/AssignmentStatement.qll @@ -0,0 +1,21 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `AssignmentStatement`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.StatementImpl::Impl as StatementImpl + +/** + * INTERNAL: This module contains the fully generated definition of `AssignmentStatement` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::AssignmentStatement` class directly. + * Use the subclass `AssignmentStatement`, where the following predicates are available. + */ + class AssignmentStatement extends Synth::TAssignmentStatement, StatementImpl::Statement { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/Ast.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/Ast.qll new file mode 100644 index 000000000000..b29174d85471 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/Ast.qll @@ -0,0 +1,25 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `Ast`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.LocatableImpl::Impl as LocatableImpl + +/** + * INTERNAL: This module contains the fully generated definition of `Ast` and should not + * be referenced directly. + */ +module Generated { + /** + * Root of the X++ abstract syntax tree. + * + * This mirrors `Microsoft.Dynamics.AX.Metadata.XppCompiler.Ast`, the base class of the + * X++ compiler's own AST. + * INTERNAL: Do not reference the `Generated::Ast` class directly. + * Use the subclass `Ast`, where the following predicates are available. + */ + class Ast extends Synth::TAst, LocatableImpl::Locatable { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/Attribute.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/Attribute.qll new file mode 100644 index 000000000000..4ce3b609bd65 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/Attribute.qll @@ -0,0 +1,89 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `Attribute`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.AstImpl::Impl as AstImpl +import codeql.xpp.elements.AttributeExpression +import codeql.xpp.elements.AttributeNamedParameterEntry + +/** + * INTERNAL: This module contains the fully generated definition of `Attribute` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::Attribute` class directly. + * Use the subclass `Attribute`, where the following predicates are available. + */ + class Attribute extends Synth::TAttribute, AstImpl::Ast { + override string getAPrimaryQlClass() { result = "Attribute" } + + /** + * Gets the name of this attribute, if it exists. + */ + string getName() { result = Synth::convertAttributeToRaw(this).(Raw::Attribute).getName() } + + /** + * Holds if `getName()` exists. + */ + final predicate hasName() { exists(this.getName()) } + + /** + * Gets the `index`th named parameter of this attribute (0-based). + */ + AttributeNamedParameterEntry getNamedParameter(int index) { + result = + Synth::convertAttributeNamedParameterEntryFromRaw(Synth::convertAttributeToRaw(this) + .(Raw::Attribute) + .getNamedParameter(index)) + } + + /** + * Gets any of the named parameters of this attribute. + */ + final AttributeNamedParameterEntry getANamedParameter() { result = this.getNamedParameter(_) } + + /** + * Gets the number of named parameters of this attribute. + */ + final int getNumberOfNamedParameters() { + result = count(int i | exists(this.getNamedParameter(i))) + } + + /** + * Gets the non fully qualified name of this attribute, if it exists. + */ + string getNonFullyQualifiedName() { + result = Synth::convertAttributeToRaw(this).(Raw::Attribute).getNonFullyQualifiedName() + } + + /** + * Holds if `getNonFullyQualifiedName()` exists. + */ + final predicate hasNonFullyQualifiedName() { exists(this.getNonFullyQualifiedName()) } + + /** + * Gets the `index`th parameter of this attribute (0-based). + */ + AttributeExpression getParameter(int index) { + result = + Synth::convertAttributeExpressionFromRaw(Synth::convertAttributeToRaw(this) + .(Raw::Attribute) + .getParameter(index)) + } + + /** + * Gets any of the parameters of this attribute. + */ + final AttributeExpression getAParameter() { result = this.getParameter(_) } + + /** + * Gets the number of parameters of this attribute. + */ + final int getNumberOfParameters() { result = count(int i | exists(this.getParameter(i))) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/AttributeExpression.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/AttributeExpression.qll new file mode 100644 index 000000000000..67b984151e5c --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/AttributeExpression.qll @@ -0,0 +1,39 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `AttributeExpression`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.AstImpl::Impl as AstImpl +import codeql.xpp.elements.AttributeLiteral + +/** + * INTERNAL: This module contains the fully generated definition of `AttributeExpression` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::AttributeExpression` class directly. + * Use the subclass `AttributeExpression`, where the following predicates are available. + */ + class AttributeExpression extends Synth::TAttributeExpression, AstImpl::Ast { + override string getAPrimaryQlClass() { result = "AttributeExpression" } + + /** + * Gets the literal of this attribute expression, if it exists. + */ + AttributeLiteral getLiteral() { + result = + Synth::convertAttributeLiteralFromRaw(Synth::convertAttributeExpressionToRaw(this) + .(Raw::AttributeExpression) + .getLiteral()) + } + + /** + * Holds if `getLiteral()` exists. + */ + final predicate hasLiteral() { exists(this.getLiteral()) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/AttributeList.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/AttributeList.qll new file mode 100644 index 000000000000..4ab08165ae0d --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/AttributeList.qll @@ -0,0 +1,51 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `AttributeList`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.AstImpl::Impl as AstImpl +import codeql.xpp.elements.Attribute + +/** + * INTERNAL: This module contains the fully generated definition of `AttributeList` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::AttributeList` class directly. + * Use the subclass `AttributeList`, where the following predicates are available. + */ + class AttributeList extends Synth::TAttributeList, AstImpl::Ast { + override string getAPrimaryQlClass() { result = "AttributeList" } + + /** + * Gets the `index`th attribute of this attribute list (0-based). + */ + Attribute getAttribute(int index) { + result = + Synth::convertAttributeFromRaw(Synth::convertAttributeListToRaw(this) + .(Raw::AttributeList) + .getAttribute(index)) + } + + /** + * Gets any of the attributes of this attribute list. + */ + final Attribute getAnAttribute() { result = this.getAttribute(_) } + + /** + * Gets the number of attributes of this attribute list. + */ + final int getNumberOfAttributes() { result = count(int i | exists(this.getAttribute(i))) } + + /** + * Holds if this attribute list contains internal use only attribute. + */ + predicate containsInternalUseOnlyAttribute() { + Synth::convertAttributeListToRaw(this).(Raw::AttributeList).containsInternalUseOnlyAttribute() + } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/AttributeLiteral.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/AttributeLiteral.qll new file mode 100644 index 000000000000..faf57c376114 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/AttributeLiteral.qll @@ -0,0 +1,21 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `AttributeLiteral`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.AstImpl::Impl as AstImpl + +/** + * INTERNAL: This module contains the fully generated definition of `AttributeLiteral` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::AttributeLiteral` class directly. + * Use the subclass `AttributeLiteral`, where the following predicates are available. + */ + class AttributeLiteral extends Synth::TAttributeLiteral, AstImpl::Ast { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/AttributeNamedParameterEntry.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/AttributeNamedParameterEntry.qll new file mode 100644 index 000000000000..74f7e089bf86 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/AttributeNamedParameterEntry.qll @@ -0,0 +1,56 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `AttributeNamedParameterEntry`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.AttributeExpression +import codeql.xpp.elements.internal.XppTupleImpl::Impl as XppTupleImpl + +/** + * INTERNAL: This module contains the fully generated definition of `AttributeNamedParameterEntry` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::AttributeNamedParameterEntry` class directly. + * Use the subclass `AttributeNamedParameterEntry`, where the following predicates are available. + */ + class AttributeNamedParameterEntry extends Synth::TAttributeNamedParameterEntry, + XppTupleImpl::XppTuple + { + override string getAPrimaryQlClass() { result = "AttributeNamedParameterEntry" } + + /** + * Gets the item1 of this attribute named parameter entry, if it exists. + */ + string getItem1() { + result = + Synth::convertAttributeNamedParameterEntryToRaw(this) + .(Raw::AttributeNamedParameterEntry) + .getItem1() + } + + /** + * Holds if `getItem1()` exists. + */ + final predicate hasItem1() { exists(this.getItem1()) } + + /** + * Gets the attribute expression of this attribute named parameter entry, if it exists. + */ + AttributeExpression getAttributeExpression() { + result = + Synth::convertAttributeExpressionFromRaw(Synth::convertAttributeNamedParameterEntryToRaw(this) + .(Raw::AttributeNamedParameterEntry) + .getAttributeExpression()) + } + + /** + * Holds if `getAttributeExpression()` exists. + */ + final predicate hasAttributeExpression() { exists(this.getAttributeExpression()) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/AvgAggregateSelection.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/AvgAggregateSelection.qll new file mode 100644 index 000000000000..c01e22ea971d --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/AvgAggregateSelection.qll @@ -0,0 +1,25 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `AvgAggregateSelection`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.AggregateSelectionImpl::Impl as AggregateSelectionImpl + +/** + * INTERNAL: This module contains the fully generated definition of `AvgAggregateSelection` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::AvgAggregateSelection` class directly. + * Use the subclass `AvgAggregateSelection`, where the following predicates are available. + */ + class AvgAggregateSelection extends Synth::TAvgAggregateSelection, + AggregateSelectionImpl::AggregateSelection + { + override string getAPrimaryQlClass() { result = "AvgAggregateSelection" } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/BinaryExpression.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/BinaryExpression.qll new file mode 100644 index 000000000000..c3f3d8ddeea1 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/BinaryExpression.qll @@ -0,0 +1,52 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `BinaryExpression`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.Expression +import codeql.xpp.elements.internal.ExpressionImpl::Impl as ExpressionImpl + +/** + * INTERNAL: This module contains the fully generated definition of `BinaryExpression` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::BinaryExpression` class directly. + * Use the subclass `BinaryExpression`, where the following predicates are available. + */ + class BinaryExpression extends Synth::TBinaryExpression, ExpressionImpl::Expression { + /** + * Gets the left of this binary expression, if it exists. + */ + Expression getLeft() { + result = + Synth::convertExpressionFromRaw(Synth::convertBinaryExpressionToRaw(this) + .(Raw::BinaryExpression) + .getLeft()) + } + + /** + * Holds if `getLeft()` exists. + */ + final predicate hasLeft() { exists(this.getLeft()) } + + /** + * Gets the right of this binary expression, if it exists. + */ + Expression getRight() { + result = + Synth::convertExpressionFromRaw(Synth::convertBinaryExpressionToRaw(this) + .(Raw::BinaryExpression) + .getRight()) + } + + /** + * Holds if `getRight()` exists. + */ + final predicate hasRight() { exists(this.getRight()) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/BooleanAttributeLiteral.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/BooleanAttributeLiteral.qll new file mode 100644 index 000000000000..5ee7cb4eb005 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/BooleanAttributeLiteral.qll @@ -0,0 +1,25 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `BooleanAttributeLiteral`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.DefaultTypeAttributeLiteralImpl::Impl as DefaultTypeAttributeLiteralImpl + +/** + * INTERNAL: This module contains the fully generated definition of `BooleanAttributeLiteral` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::BooleanAttributeLiteral` class directly. + * Use the subclass `BooleanAttributeLiteral`, where the following predicates are available. + */ + class BooleanAttributeLiteral extends Synth::TBooleanAttributeLiteral, + DefaultTypeAttributeLiteralImpl::DefaultTypeAttributeLiteral + { + override string getAPrimaryQlClass() { result = "BooleanAttributeLiteral" } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/BooleanLiteralExpression.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/BooleanLiteralExpression.qll new file mode 100644 index 000000000000..eb9965c3a01b --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/BooleanLiteralExpression.qll @@ -0,0 +1,25 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `BooleanLiteralExpression`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.DefaultTypeLiteralExpressionImpl::Impl as DefaultTypeLiteralExpressionImpl + +/** + * INTERNAL: This module contains the fully generated definition of `BooleanLiteralExpression` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::BooleanLiteralExpression` class directly. + * Use the subclass `BooleanLiteralExpression`, where the following predicates are available. + */ + class BooleanLiteralExpression extends Synth::TBooleanLiteralExpression, + DefaultTypeLiteralExpressionImpl::DefaultTypeLiteralExpression + { + override string getAPrimaryQlClass() { result = "BooleanLiteralExpression" } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/BooleanType.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/BooleanType.qll new file mode 100644 index 000000000000..17a47afdd068 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/BooleanType.qll @@ -0,0 +1,23 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `BooleanType`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.XppTypeImpl::Impl as XppTypeImpl + +/** + * INTERNAL: This module contains the fully generated definition of `BooleanType` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::BooleanType` class directly. + * Use the subclass `BooleanType`, where the following predicates are available. + */ + class BooleanType extends Synth::TBooleanType, XppTypeImpl::XppType { + override string getAPrimaryQlClass() { result = "BooleanType" } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/BreakStatement.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/BreakStatement.qll new file mode 100644 index 000000000000..fb82b89da3d0 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/BreakStatement.qll @@ -0,0 +1,23 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `BreakStatement`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.StatementImpl::Impl as StatementImpl + +/** + * INTERNAL: This module contains the fully generated definition of `BreakStatement` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::BreakStatement` class directly. + * Use the subclass `BreakStatement`, where the following predicates are available. + */ + class BreakStatement extends Synth::TBreakStatement, StatementImpl::Statement { + override string getAPrimaryQlClass() { result = "BreakStatement" } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/BreakpointStatement.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/BreakpointStatement.qll new file mode 100644 index 000000000000..e216b67f998c --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/BreakpointStatement.qll @@ -0,0 +1,23 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `BreakpointStatement`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.StatementImpl::Impl as StatementImpl + +/** + * INTERNAL: This module contains the fully generated definition of `BreakpointStatement` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::BreakpointStatement` class directly. + * Use the subclass `BreakpointStatement`, where the following predicates are available. + */ + class BreakpointStatement extends Synth::TBreakpointStatement, StatementImpl::Statement { + override string getAPrimaryQlClass() { result = "BreakpointStatement" } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/Case.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/Case.qll new file mode 100644 index 000000000000..eff083742113 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/Case.qll @@ -0,0 +1,21 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `Case`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.AstImpl::Impl as AstImpl + +/** + * INTERNAL: This module contains the fully generated definition of `Case` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::Case` class directly. + * Use the subclass `Case`, where the following predicates are available. + */ + class Case extends Synth::TCase, AstImpl::Ast { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/CaseDefault.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/CaseDefault.qll new file mode 100644 index 000000000000..709f9a37807b --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/CaseDefault.qll @@ -0,0 +1,23 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `CaseDefault`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.CaseImpl::Impl as CaseImpl + +/** + * INTERNAL: This module contains the fully generated definition of `CaseDefault` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::CaseDefault` class directly. + * Use the subclass `CaseDefault`, where the following predicates are available. + */ + class CaseDefault extends Synth::TCaseDefault, CaseImpl::Case { + override string getAPrimaryQlClass() { result = "CaseDefault" } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/CaseValues.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/CaseValues.qll new file mode 100644 index 000000000000..8cb22896d255 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/CaseValues.qll @@ -0,0 +1,44 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `CaseValues`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.CaseImpl::Impl as CaseImpl +import codeql.xpp.elements.Expression + +/** + * INTERNAL: This module contains the fully generated definition of `CaseValues` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::CaseValues` class directly. + * Use the subclass `CaseValues`, where the following predicates are available. + */ + class CaseValues extends Synth::TCaseValues, CaseImpl::Case { + override string getAPrimaryQlClass() { result = "CaseValues" } + + /** + * Gets the `index`th value of this case values (0-based). + */ + Expression getValue(int index) { + result = + Synth::convertExpressionFromRaw(Synth::convertCaseValuesToRaw(this) + .(Raw::CaseValues) + .getValue(index)) + } + + /** + * Gets any of the values of this case values. + */ + final Expression getAValue() { result = this.getValue(_) } + + /** + * Gets the number of values of this case values. + */ + final int getNumberOfValues() { result = count(int i | exists(this.getValue(i))) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/Catch.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/Catch.qll new file mode 100644 index 000000000000..ad118dfe6beb --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/Catch.qll @@ -0,0 +1,21 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `Catch`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.AstImpl::Impl as AstImpl + +/** + * INTERNAL: This module contains the fully generated definition of `Catch` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::Catch` class directly. + * Use the subclass `Catch`, where the following predicates are available. + */ + class Catch extends Synth::TCatch, AstImpl::Ast { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/CatchAllValues.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/CatchAllValues.qll new file mode 100644 index 000000000000..d136a338ba0c --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/CatchAllValues.qll @@ -0,0 +1,23 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `CatchAllValues`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.CatchImpl::Impl as CatchImpl + +/** + * INTERNAL: This module contains the fully generated definition of `CatchAllValues` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::CatchAllValues` class directly. + * Use the subclass `CatchAllValues`, where the following predicates are available. + */ + class CatchAllValues extends Synth::TCatchAllValues, CatchImpl::Catch { + override string getAPrimaryQlClass() { result = "CatchAllValues" } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/CatchExpression.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/CatchExpression.qll new file mode 100644 index 000000000000..9f7df58c14df --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/CatchExpression.qll @@ -0,0 +1,39 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `CatchExpression`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.CatchImpl::Impl as CatchImpl +import codeql.xpp.elements.Expression + +/** + * INTERNAL: This module contains the fully generated definition of `CatchExpression` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::CatchExpression` class directly. + * Use the subclass `CatchExpression`, where the following predicates are available. + */ + class CatchExpression extends Synth::TCatchExpression, CatchImpl::Catch { + override string getAPrimaryQlClass() { result = "CatchExpression" } + + /** + * Gets the expression of this catch expression, if it exists. + */ + Expression getExpression() { + result = + Synth::convertExpressionFromRaw(Synth::convertCatchExpressionToRaw(this) + .(Raw::CatchExpression) + .getExpression()) + } + + /** + * Holds if `getExpression()` exists. + */ + final predicate hasExpression() { exists(this.getExpression()) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/CatchUpdateConflict.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/CatchUpdateConflict.qll new file mode 100644 index 000000000000..d8c957a6d0b9 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/CatchUpdateConflict.qll @@ -0,0 +1,55 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `CatchUpdateConflict`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.CatchImpl::Impl as CatchImpl +import codeql.xpp.elements.Expression +import codeql.xpp.elements.InstanceName + +/** + * INTERNAL: This module contains the fully generated definition of `CatchUpdateConflict` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::CatchUpdateConflict` class directly. + * Use the subclass `CatchUpdateConflict`, where the following predicates are available. + */ + class CatchUpdateConflict extends Synth::TCatchUpdateConflict, CatchImpl::Catch { + override string getAPrimaryQlClass() { result = "CatchUpdateConflict" } + + /** + * Gets the expression of this catch update conflict, if it exists. + */ + Expression getExpression() { + result = + Synth::convertExpressionFromRaw(Synth::convertCatchUpdateConflictToRaw(this) + .(Raw::CatchUpdateConflict) + .getExpression()) + } + + /** + * Holds if `getExpression()` exists. + */ + final predicate hasExpression() { exists(this.getExpression()) } + + /** + * Gets the instance of this catch update conflict, if it exists. + */ + InstanceName getInstance() { + result = + Synth::convertInstanceNameFromRaw(Synth::convertCatchUpdateConflictToRaw(this) + .(Raw::CatchUpdateConflict) + .getInstance()) + } + + /** + * Holds if `getInstance()` exists. + */ + final predicate hasInstance() { exists(this.getInstance()) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/ChangeCompanyStatement.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/ChangeCompanyStatement.qll new file mode 100644 index 000000000000..f700d59c2d14 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/ChangeCompanyStatement.qll @@ -0,0 +1,25 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `ChangeCompanyStatement`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.ChangeStatementImpl::Impl as ChangeStatementImpl + +/** + * INTERNAL: This module contains the fully generated definition of `ChangeCompanyStatement` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::ChangeCompanyStatement` class directly. + * Use the subclass `ChangeCompanyStatement`, where the following predicates are available. + */ + class ChangeCompanyStatement extends Synth::TChangeCompanyStatement, + ChangeStatementImpl::ChangeStatement + { + override string getAPrimaryQlClass() { result = "ChangeCompanyStatement" } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/ChangeStatement.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/ChangeStatement.qll new file mode 100644 index 000000000000..756e77936039 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/ChangeStatement.qll @@ -0,0 +1,53 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `ChangeStatement`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.Expression +import codeql.xpp.elements.Statement +import codeql.xpp.elements.internal.StatementImpl::Impl as StatementImpl + +/** + * INTERNAL: This module contains the fully generated definition of `ChangeStatement` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::ChangeStatement` class directly. + * Use the subclass `ChangeStatement`, where the following predicates are available. + */ + class ChangeStatement extends Synth::TChangeStatement, StatementImpl::Statement { + /** + * Gets the expression of this change statement, if it exists. + */ + Expression getExpression() { + result = + Synth::convertExpressionFromRaw(Synth::convertChangeStatementToRaw(this) + .(Raw::ChangeStatement) + .getExpression()) + } + + /** + * Holds if `getExpression()` exists. + */ + final predicate hasExpression() { exists(this.getExpression()) } + + /** + * Gets the statement of this change statement, if it exists. + */ + Statement getStatement() { + result = + Synth::convertStatementFromRaw(Synth::convertChangeStatementToRaw(this) + .(Raw::ChangeStatement) + .getStatement()) + } + + /** + * Holds if `getStatement()` exists. + */ + final predicate hasStatement() { exists(this.getStatement()) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/Class.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/Class.qll new file mode 100644 index 000000000000..bb7a35719f80 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/Class.qll @@ -0,0 +1,68 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `Class`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.ClassOrInterfaceImpl::Impl as ClassOrInterfaceImpl +import codeql.xpp.elements.FieldDeclaration + +/** + * INTERNAL: This module contains the fully generated definition of `Class` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::Class` class directly. + * Use the subclass `Class`, where the following predicates are available. + */ + class Class extends Synth::TClass, ClassOrInterfaceImpl::ClassOrInterface { + override string getAPrimaryQlClass() { result = "Class" } + + /** + * Gets the `index`th field of this class (0-based). + */ + FieldDeclaration getField(int index) { + result = + Synth::convertFieldDeclarationFromRaw(Synth::convertClassToRaw(this) + .(Raw::Class) + .getField(index)) + } + + /** + * Gets any of the fields of this class. + */ + final FieldDeclaration getAField() { result = this.getField(_) } + + /** + * Gets the number of fields of this class. + */ + final int getNumberOfFields() { result = count(int i | exists(this.getField(i))) } + + /** + * Holds if this class has cyclic inheritance. + */ + predicate hasCyclicInheritance() { + Synth::convertClassToRaw(this).(Raw::Class).hasCyclicInheritance() + } + + /** + * Gets the `index`th implement of this class (0-based). + */ + string getImplement(int index) { + result = Synth::convertClassToRaw(this).(Raw::Class).getImplement(index) + } + + /** + * Gets any of the implements of this class. + */ + final string getAnImplement() { result = this.getImplement(_) } + + /** + * Gets the number of implements of this class. + */ + final int getNumberOfImplements() { result = count(int i | exists(this.getImplement(i))) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/ClassAccessModifier.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/ClassAccessModifier.qll new file mode 100644 index 000000000000..01d68a418b84 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/ClassAccessModifier.qll @@ -0,0 +1,36 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `ClassAccessModifier`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.AstImpl::Impl as AstImpl + +/** + * INTERNAL: This module contains the fully generated definition of `ClassAccessModifier` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::ClassAccessModifier` class directly. + * Use the subclass `ClassAccessModifier`, where the following predicates are available. + */ + class ClassAccessModifier extends Synth::TClassAccessModifier, AstImpl::Ast { + override string getAPrimaryQlClass() { result = "ClassAccessModifier" } + + /** + * Gets the class modifiers of this class access modifier, if it exists. + */ + string getClassModifiers() { + result = + Synth::convertClassAccessModifierToRaw(this).(Raw::ClassAccessModifier).getClassModifiers() + } + + /** + * Holds if `getClassModifiers()` exists. + */ + final predicate hasClassModifiers() { exists(this.getClassModifiers()) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/ClassOrInterface.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/ClassOrInterface.qll new file mode 100644 index 000000000000..a6615f14f580 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/ClassOrInterface.qll @@ -0,0 +1,125 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `ClassOrInterface`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.AttributeList +import codeql.xpp.elements.ModelElement +import codeql.xpp.elements.internal.ModelElementImpl::Impl as ModelElementImpl + +/** + * INTERNAL: This module contains the fully generated definition of `ClassOrInterface` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::ClassOrInterface` class directly. + * Use the subclass `ClassOrInterface`, where the following predicates are available. + */ + class ClassOrInterface extends Synth::TClassOrInterface, ModelElementImpl::ModelElement { + /** + * Gets the attributes of this class or interface, if it exists. + */ + AttributeList getAttributes() { + result = + Synth::convertAttributeListFromRaw(Synth::convertClassOrInterfaceToRaw(this) + .(Raw::ClassOrInterface) + .getAttributes()) + } + + /** + * Holds if `getAttributes()` exists. + */ + final predicate hasAttributes() { exists(this.getAttributes()) } + + /** + * Gets the element type name of this class or interface, if it exists. + */ + string getElementTypeName() { + result = + Synth::convertClassOrInterfaceToRaw(this).(Raw::ClassOrInterface).getElementTypeName() + } + + /** + * Holds if `getElementTypeName()` exists. + */ + final predicate hasElementTypeName() { exists(this.getElementTypeName()) } + + /** + * Gets the enclosing type of this class or interface, if it exists. + */ + ModelElement getEnclosingType() { + result = + Synth::convertModelElementFromRaw(Synth::convertClassOrInterfaceToRaw(this) + .(Raw::ClassOrInterface) + .getEnclosingType()) + } + + /** + * Holds if `getEnclosingType()` exists. + */ + final predicate hasEnclosingType() { exists(this.getEnclosingType()) } + + /** + * Gets the extends of this class or interface, if it exists. + */ + string getExtends() { + result = Synth::convertClassOrInterfaceToRaw(this).(Raw::ClassOrInterface).getExtends() + } + + /** + * Holds if `getExtends()` exists. + */ + final predicate hasExtends() { exists(this.getExtends()) } + + /** + * Holds if this class or interface is abstract. + */ + predicate isAbstract() { + Synth::convertClassOrInterfaceToRaw(this).(Raw::ClassOrInterface).isAbstract() + } + + /** + * Holds if this class or interface is composite data entity view. + */ + predicate isCompositeDataEntityView() { + Synth::convertClassOrInterfaceToRaw(this).(Raw::ClassOrInterface).isCompositeDataEntityView() + } + + /** + * Holds if this class or interface is final. + */ + predicate isFinal() { + Synth::convertClassOrInterfaceToRaw(this).(Raw::ClassOrInterface).isFinal() + } + + /** + * Holds if this class or interface is nested. + */ + predicate isNested() { + Synth::convertClassOrInterfaceToRaw(this).(Raw::ClassOrInterface).isNested() + } + + /** + * Holds if this class or interface is static. + */ + predicate isStatic() { + Synth::convertClassOrInterfaceToRaw(this).(Raw::ClassOrInterface).isStatic() + } + + /** + * Gets the qualifier of this class or interface, if it exists. + */ + string getQualifier() { + result = Synth::convertClassOrInterfaceToRaw(this).(Raw::ClassOrInterface).getQualifier() + } + + /** + * Holds if `getQualifier()` exists. + */ + final predicate hasQualifier() { exists(this.getQualifier()) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/ClrEnumerationLiteralExpression.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/ClrEnumerationLiteralExpression.qll new file mode 100644 index 000000000000..11a30abb3605 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/ClrEnumerationLiteralExpression.qll @@ -0,0 +1,55 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `ClrEnumerationLiteralExpression`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.LiteralExpressionImpl::Impl as LiteralExpressionImpl + +/** + * INTERNAL: This module contains the fully generated definition of `ClrEnumerationLiteralExpression` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::ClrEnumerationLiteralExpression` class directly. + * Use the subclass `ClrEnumerationLiteralExpression`, where the following predicates are available. + */ + class ClrEnumerationLiteralExpression extends Synth::TClrEnumerationLiteralExpression, + LiteralExpressionImpl::LiteralExpression + { + override string getAPrimaryQlClass() { result = "ClrEnumerationLiteralExpression" } + + /** + * Gets the enumeration literal of this clr enumeration literal expression, if it exists. + */ + string getEnumerationLiteral() { + result = + Synth::convertClrEnumerationLiteralExpressionToRaw(this) + .(Raw::ClrEnumerationLiteralExpression) + .getEnumerationLiteral() + } + + /** + * Holds if `getEnumerationLiteral()` exists. + */ + final predicate hasEnumerationLiteral() { exists(this.getEnumerationLiteral()) } + + /** + * Gets the enumeration type of this clr enumeration literal expression, if it exists. + */ + string getEnumerationType() { + result = + Synth::convertClrEnumerationLiteralExpressionToRaw(this) + .(Raw::ClrEnumerationLiteralExpression) + .getEnumerationType() + } + + /** + * Holds if `getEnumerationType()` exists. + */ + final predicate hasEnumerationType() { exists(this.getEnumerationType()) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/ClrType.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/ClrType.qll new file mode 100644 index 000000000000..f330e8a7fe21 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/ClrType.qll @@ -0,0 +1,52 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `ClrType`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.GenericXppTypeImpl::Impl as GenericXppTypeImpl + +/** + * INTERNAL: This module contains the fully generated definition of `ClrType` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::ClrType` class directly. + * Use the subclass `ClrType`, where the following predicates are available. + */ + class ClrType extends Synth::TClrType, GenericXppTypeImpl::GenericXppType { + override string getAPrimaryQlClass() { result = "ClrType" } + + /** + * Gets the full name of this clr type, if it exists. + */ + string getFullName() { result = Synth::convertClrTypeToRaw(this).(Raw::ClrType).getFullName() } + + /** + * Holds if `getFullName()` exists. + */ + final predicate hasFullName() { exists(this.getFullName()) } + + /** + * Gets the `index`th rectangular dimension of this clr type (0-based). + */ + int getRectangularDimension(int index) { + result = Synth::convertClrTypeToRaw(this).(Raw::ClrType).getRectangularDimension(index) + } + + /** + * Gets any of the rectangular dimensions of this clr type. + */ + final int getARectangularDimension() { result = this.getRectangularDimension(_) } + + /** + * Gets the number of rectangular dimensions of this clr type. + */ + final int getNumberOfRectangularDimensions() { + result = count(int i | exists(this.getRectangularDimension(i))) + } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/Comment.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/Comment.qll new file mode 100644 index 000000000000..69f90d0096fa --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/Comment.qll @@ -0,0 +1,34 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `Comment`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.LocatableImpl::Impl as LocatableImpl + +/** + * INTERNAL: This module contains the fully generated definition of `Comment` and should not + * be referenced directly. + */ +module Generated { + /** + * A comment in X++ source. + * INTERNAL: Do not reference the `Generated::Comment` class directly. + * Use the subclass `Comment`, where the following predicates are available. + */ + class Comment extends Synth::TComment, LocatableImpl::Locatable { + override string getAPrimaryQlClass() { result = "Comment" } + + /** + * Gets the text of this comment, if it exists. + */ + string getText() { result = Synth::convertCommentToRaw(this).(Raw::Comment).getText() } + + /** + * Holds if `getText()` exists. + */ + final predicate hasText() { exists(this.getText()) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/CompilationUnit.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/CompilationUnit.qll new file mode 100644 index 000000000000..ea067355a5d4 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/CompilationUnit.qll @@ -0,0 +1,84 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `CompilationUnit`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.AstImpl::Impl as AstImpl +import codeql.xpp.elements.Comment +import codeql.xpp.elements.CompilationUnitRegionEntry + +/** + * INTERNAL: This module contains the fully generated definition of `CompilationUnit` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::CompilationUnit` class directly. + * Use the subclass `CompilationUnit`, where the following predicates are available. + */ + class CompilationUnit extends Synth::TCompilationUnit, AstImpl::Ast { + /** + * Gets the comments of this compilation unit, if it exists. + */ + Comment getComments() { + result = + Synth::convertCommentFromRaw(Synth::convertCompilationUnitToRaw(this) + .(Raw::CompilationUnit) + .getComments()) + } + + /** + * Holds if `getComments()` exists. + */ + final predicate hasComments() { exists(this.getComments()) } + + /** + * Holds if this compilation unit is name escaped. + */ + predicate isNameEscaped() { + Synth::convertCompilationUnitToRaw(this).(Raw::CompilationUnit).isNameEscaped() + } + + /** + * Gets the name of this compilation unit, if it exists. + */ + string getName() { + result = Synth::convertCompilationUnitToRaw(this).(Raw::CompilationUnit).getName() + } + + /** + * Holds if `getName()` exists. + */ + final predicate hasName() { exists(this.getName()) } + + /** + * Holds if this compilation unit needs transformation. + */ + predicate needsTransformation() { + Synth::convertCompilationUnitToRaw(this).(Raw::CompilationUnit).needsTransformation() + } + + /** + * Gets the `index`th region of this compilation unit (0-based). + */ + CompilationUnitRegionEntry getRegion(int index) { + result = + Synth::convertCompilationUnitRegionEntryFromRaw(Synth::convertCompilationUnitToRaw(this) + .(Raw::CompilationUnit) + .getRegion(index)) + } + + /** + * Gets any of the regions of this compilation unit. + */ + final CompilationUnitRegionEntry getARegion() { result = this.getRegion(_) } + + /** + * Gets the number of regions of this compilation unit. + */ + final int getNumberOfRegions() { result = count(int i | exists(this.getRegion(i))) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/CompilationUnitRegionEntry.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/CompilationUnitRegionEntry.qll new file mode 100644 index 000000000000..e559df72fb1f --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/CompilationUnitRegionEntry.qll @@ -0,0 +1,56 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `CompilationUnitRegionEntry`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.Comment +import codeql.xpp.elements.internal.XppTupleImpl::Impl as XppTupleImpl + +/** + * INTERNAL: This module contains the fully generated definition of `CompilationUnitRegionEntry` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::CompilationUnitRegionEntry` class directly. + * Use the subclass `CompilationUnitRegionEntry`, where the following predicates are available. + */ + class CompilationUnitRegionEntry extends Synth::TCompilationUnitRegionEntry, + XppTupleImpl::XppTuple + { + override string getAPrimaryQlClass() { result = "CompilationUnitRegionEntry" } + + /** + * Gets the comment of this compilation unit region entry, if it exists. + */ + Comment getComment() { + result = + Synth::convertCommentFromRaw(Synth::convertCompilationUnitRegionEntryToRaw(this) + .(Raw::CompilationUnitRegionEntry) + .getComment()) + } + + /** + * Holds if `getComment()` exists. + */ + final predicate hasComment() { exists(this.getComment()) } + + /** + * Gets the comment2 of this compilation unit region entry, if it exists. + */ + Comment getComment2() { + result = + Synth::convertCommentFromRaw(Synth::convertCompilationUnitRegionEntryToRaw(this) + .(Raw::CompilationUnitRegionEntry) + .getComment2()) + } + + /** + * Holds if `getComment2()` exists. + */ + final predicate hasComment2() { exists(this.getComment2()) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/CompoundStatement.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/CompoundStatement.qll new file mode 100644 index 000000000000..1f5f1e0b4dcf --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/CompoundStatement.qll @@ -0,0 +1,44 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `CompoundStatement`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.Statement +import codeql.xpp.elements.internal.StatementImpl::Impl as StatementImpl + +/** + * INTERNAL: This module contains the fully generated definition of `CompoundStatement` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::CompoundStatement` class directly. + * Use the subclass `CompoundStatement`, where the following predicates are available. + */ + class CompoundStatement extends Synth::TCompoundStatement, StatementImpl::Statement { + override string getAPrimaryQlClass() { result = "CompoundStatement" } + + /** + * Gets the `index`th content of this compound statement (0-based). + */ + Statement getContent(int index) { + result = + Synth::convertStatementFromRaw(Synth::convertCompoundStatementToRaw(this) + .(Raw::CompoundStatement) + .getContent(index)) + } + + /** + * Gets any of the contents of this compound statement. + */ + final Statement getAContent() { result = this.getContent(_) } + + /** + * Gets the number of contents of this compound statement. + */ + final int getNumberOfContents() { result = count(int i | exists(this.getContent(i))) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/ConditionalExpression.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/ConditionalExpression.qll new file mode 100644 index 000000000000..9aed2c942934 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/ConditionalExpression.qll @@ -0,0 +1,69 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `ConditionalExpression`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.Expression +import codeql.xpp.elements.internal.ExpressionImpl::Impl as ExpressionImpl + +/** + * INTERNAL: This module contains the fully generated definition of `ConditionalExpression` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::ConditionalExpression` class directly. + * Use the subclass `ConditionalExpression`, where the following predicates are available. + */ + class ConditionalExpression extends Synth::TConditionalExpression, ExpressionImpl::Expression { + override string getAPrimaryQlClass() { result = "ConditionalExpression" } + + /** + * Gets the condition of this conditional expression, if it exists. + */ + Expression getCondition() { + result = + Synth::convertExpressionFromRaw(Synth::convertConditionalExpressionToRaw(this) + .(Raw::ConditionalExpression) + .getCondition()) + } + + /** + * Holds if `getCondition()` exists. + */ + final predicate hasCondition() { exists(this.getCondition()) } + + /** + * Gets the else part of this conditional expression, if it exists. + */ + Expression getElsePart() { + result = + Synth::convertExpressionFromRaw(Synth::convertConditionalExpressionToRaw(this) + .(Raw::ConditionalExpression) + .getElsePart()) + } + + /** + * Holds if `getElsePart()` exists. + */ + final predicate hasElsePart() { exists(this.getElsePart()) } + + /** + * Gets the if part of this conditional expression, if it exists. + */ + Expression getIfPart() { + result = + Synth::convertExpressionFromRaw(Synth::convertConditionalExpressionToRaw(this) + .(Raw::ConditionalExpression) + .getIfPart()) + } + + /** + * Holds if `getIfPart()` exists. + */ + final predicate hasIfPart() { exists(this.getIfPart()) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/ContainerAttributeLiteral.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/ContainerAttributeLiteral.qll new file mode 100644 index 000000000000..59b66b18c36a --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/ContainerAttributeLiteral.qll @@ -0,0 +1,46 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `ContainerAttributeLiteral`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.AttributeExpression +import codeql.xpp.elements.internal.AttributeLiteralImpl::Impl as AttributeLiteralImpl + +/** + * INTERNAL: This module contains the fully generated definition of `ContainerAttributeLiteral` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::ContainerAttributeLiteral` class directly. + * Use the subclass `ContainerAttributeLiteral`, where the following predicates are available. + */ + class ContainerAttributeLiteral extends Synth::TContainerAttributeLiteral, + AttributeLiteralImpl::AttributeLiteral + { + override string getAPrimaryQlClass() { result = "ContainerAttributeLiteral" } + + /** + * Gets the `index`th value of this container attribute literal (0-based). + */ + AttributeExpression getValue(int index) { + result = + Synth::convertAttributeExpressionFromRaw(Synth::convertContainerAttributeLiteralToRaw(this) + .(Raw::ContainerAttributeLiteral) + .getValue(index)) + } + + /** + * Gets any of the values of this container attribute literal. + */ + final AttributeExpression getAValue() { result = this.getValue(_) } + + /** + * Gets the number of values of this container attribute literal. + */ + final int getNumberOfValues() { result = count(int i | exists(this.getValue(i))) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/ContainerLiteralExpression.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/ContainerLiteralExpression.qll new file mode 100644 index 000000000000..5dd8ef8a6162 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/ContainerLiteralExpression.qll @@ -0,0 +1,46 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `ContainerLiteralExpression`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.Expression +import codeql.xpp.elements.internal.LiteralExpressionImpl::Impl as LiteralExpressionImpl + +/** + * INTERNAL: This module contains the fully generated definition of `ContainerLiteralExpression` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::ContainerLiteralExpression` class directly. + * Use the subclass `ContainerLiteralExpression`, where the following predicates are available. + */ + class ContainerLiteralExpression extends Synth::TContainerLiteralExpression, + LiteralExpressionImpl::LiteralExpression + { + override string getAPrimaryQlClass() { result = "ContainerLiteralExpression" } + + /** + * Gets the `index`th value of this container literal expression (0-based). + */ + Expression getValue(int index) { + result = + Synth::convertExpressionFromRaw(Synth::convertContainerLiteralExpressionToRaw(this) + .(Raw::ContainerLiteralExpression) + .getValue(index)) + } + + /** + * Gets any of the values of this container literal expression. + */ + final Expression getAValue() { result = this.getValue(_) } + + /** + * Gets the number of values of this container literal expression. + */ + final int getNumberOfValues() { result = count(int i | exists(this.getValue(i))) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/ContainerType.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/ContainerType.qll new file mode 100644 index 000000000000..e88bf46c8813 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/ContainerType.qll @@ -0,0 +1,23 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `ContainerType`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.XppTypeImpl::Impl as XppTypeImpl + +/** + * INTERNAL: This module contains the fully generated definition of `ContainerType` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::ContainerType` class directly. + * Use the subclass `ContainerType`, where the following predicates are available. + */ + class ContainerType extends Synth::TContainerType, XppTypeImpl::XppType { + override string getAPrimaryQlClass() { result = "ContainerType" } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/ContinueStatement.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/ContinueStatement.qll new file mode 100644 index 000000000000..d8ac32ff3c79 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/ContinueStatement.qll @@ -0,0 +1,23 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `ContinueStatement`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.StatementImpl::Impl as StatementImpl + +/** + * INTERNAL: This module contains the fully generated definition of `ContinueStatement` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::ContinueStatement` class directly. + * Use the subclass `ContinueStatement`, where the following predicates are available. + */ + class ContinueStatement extends Synth::TContinueStatement, StatementImpl::Statement { + override string getAPrimaryQlClass() { result = "ContinueStatement" } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/CountAggregateSelection.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/CountAggregateSelection.qll new file mode 100644 index 000000000000..d680d4462f17 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/CountAggregateSelection.qll @@ -0,0 +1,25 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `CountAggregateSelection`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.AggregateSelectionImpl::Impl as AggregateSelectionImpl + +/** + * INTERNAL: This module contains the fully generated definition of `CountAggregateSelection` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::CountAggregateSelection` class directly. + * Use the subclass `CountAggregateSelection`, where the following predicates are available. + */ + class CountAggregateSelection extends Synth::TCountAggregateSelection, + AggregateSelectionImpl::AggregateSelection + { + override string getAPrimaryQlClass() { result = "CountAggregateSelection" } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/CrossCompany.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/CrossCompany.qll new file mode 100644 index 000000000000..0f6526f2447c --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/CrossCompany.qll @@ -0,0 +1,21 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `CrossCompany`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.AstImpl::Impl as AstImpl + +/** + * INTERNAL: This module contains the fully generated definition of `CrossCompany` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::CrossCompany` class directly. + * Use the subclass `CrossCompany`, where the following predicates are available. + */ + class CrossCompany extends Synth::TCrossCompany, AstImpl::Ast { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/CrossCompanyAll.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/CrossCompanyAll.qll new file mode 100644 index 000000000000..1c263b3a4c4d --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/CrossCompanyAll.qll @@ -0,0 +1,23 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `CrossCompanyAll`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.CrossCompanyImpl::Impl as CrossCompanyImpl + +/** + * INTERNAL: This module contains the fully generated definition of `CrossCompanyAll` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::CrossCompanyAll` class directly. + * Use the subclass `CrossCompanyAll`, where the following predicates are available. + */ + class CrossCompanyAll extends Synth::TCrossCompanyAll, CrossCompanyImpl::CrossCompany { + override string getAPrimaryQlClass() { result = "CrossCompanyAll" } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/CrossCompanyContainer.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/CrossCompanyContainer.qll new file mode 100644 index 000000000000..ec54c0c11792 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/CrossCompanyContainer.qll @@ -0,0 +1,39 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `CrossCompanyContainer`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.CrossCompanyImpl::Impl as CrossCompanyImpl +import codeql.xpp.elements.Expression + +/** + * INTERNAL: This module contains the fully generated definition of `CrossCompanyContainer` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::CrossCompanyContainer` class directly. + * Use the subclass `CrossCompanyContainer`, where the following predicates are available. + */ + class CrossCompanyContainer extends Synth::TCrossCompanyContainer, CrossCompanyImpl::CrossCompany { + override string getAPrimaryQlClass() { result = "CrossCompanyContainer" } + + /** + * Gets the container of this cross company container, if it exists. + */ + Expression getContainer() { + result = + Synth::convertExpressionFromRaw(Synth::convertCrossCompanyContainerToRaw(this) + .(Raw::CrossCompanyContainer) + .getContainer()) + } + + /** + * Holds if `getContainer()` exists. + */ + final predicate hasContainer() { exists(this.getContainer()) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/DateAttributeLiteral.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/DateAttributeLiteral.qll new file mode 100644 index 000000000000..dabf20f2edc1 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/DateAttributeLiteral.qll @@ -0,0 +1,25 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `DateAttributeLiteral`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.DefaultTypeAttributeLiteralImpl::Impl as DefaultTypeAttributeLiteralImpl + +/** + * INTERNAL: This module contains the fully generated definition of `DateAttributeLiteral` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::DateAttributeLiteral` class directly. + * Use the subclass `DateAttributeLiteral`, where the following predicates are available. + */ + class DateAttributeLiteral extends Synth::TDateAttributeLiteral, + DefaultTypeAttributeLiteralImpl::DefaultTypeAttributeLiteral + { + override string getAPrimaryQlClass() { result = "DateAttributeLiteral" } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/DateLiteralExpression.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/DateLiteralExpression.qll new file mode 100644 index 000000000000..0ffbf815aeab --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/DateLiteralExpression.qll @@ -0,0 +1,25 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `DateLiteralExpression`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.DefaultTypeLiteralExpressionImpl::Impl as DefaultTypeLiteralExpressionImpl + +/** + * INTERNAL: This module contains the fully generated definition of `DateLiteralExpression` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::DateLiteralExpression` class directly. + * Use the subclass `DateLiteralExpression`, where the following predicates are available. + */ + class DateLiteralExpression extends Synth::TDateLiteralExpression, + DefaultTypeLiteralExpressionImpl::DefaultTypeLiteralExpression + { + override string getAPrimaryQlClass() { result = "DateLiteralExpression" } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/DateTimeAttributeLiteral.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/DateTimeAttributeLiteral.qll new file mode 100644 index 000000000000..60d2b8b0ba7a --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/DateTimeAttributeLiteral.qll @@ -0,0 +1,25 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `DateTimeAttributeLiteral`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.DefaultTypeAttributeLiteralImpl::Impl as DefaultTypeAttributeLiteralImpl + +/** + * INTERNAL: This module contains the fully generated definition of `DateTimeAttributeLiteral` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::DateTimeAttributeLiteral` class directly. + * Use the subclass `DateTimeAttributeLiteral`, where the following predicates are available. + */ + class DateTimeAttributeLiteral extends Synth::TDateTimeAttributeLiteral, + DefaultTypeAttributeLiteralImpl::DefaultTypeAttributeLiteral + { + override string getAPrimaryQlClass() { result = "DateTimeAttributeLiteral" } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/DateTimeLiteralExpression.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/DateTimeLiteralExpression.qll new file mode 100644 index 000000000000..ea70474ee8f6 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/DateTimeLiteralExpression.qll @@ -0,0 +1,25 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `DateTimeLiteralExpression`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.DefaultTypeLiteralExpressionImpl::Impl as DefaultTypeLiteralExpressionImpl + +/** + * INTERNAL: This module contains the fully generated definition of `DateTimeLiteralExpression` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::DateTimeLiteralExpression` class directly. + * Use the subclass `DateTimeLiteralExpression`, where the following predicates are available. + */ + class DateTimeLiteralExpression extends Synth::TDateTimeLiteralExpression, + DefaultTypeLiteralExpressionImpl::DefaultTypeLiteralExpression + { + override string getAPrimaryQlClass() { result = "DateTimeLiteralExpression" } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/DateTimeType.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/DateTimeType.qll new file mode 100644 index 000000000000..8f60c8b00767 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/DateTimeType.qll @@ -0,0 +1,23 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `DateTimeType`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.XppTypeImpl::Impl as XppTypeImpl + +/** + * INTERNAL: This module contains the fully generated definition of `DateTimeType` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::DateTimeType` class directly. + * Use the subclass `DateTimeType`, where the following predicates are available. + */ + class DateTimeType extends Synth::TDateTimeType, XppTypeImpl::XppType { + override string getAPrimaryQlClass() { result = "DateTimeType" } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/DateType.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/DateType.qll new file mode 100644 index 000000000000..89e6d8217991 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/DateType.qll @@ -0,0 +1,23 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `DateType`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.XppTypeImpl::Impl as XppTypeImpl + +/** + * INTERNAL: This module contains the fully generated definition of `DateType` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::DateType` class directly. + * Use the subclass `DateType`, where the following predicates are available. + */ + class DateType extends Synth::TDateType, XppTypeImpl::XppType { + override string getAPrimaryQlClass() { result = "DateType" } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/DblAttributeLiteral.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/DblAttributeLiteral.qll new file mode 100644 index 000000000000..31cf1a52351a --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/DblAttributeLiteral.qll @@ -0,0 +1,25 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `DblAttributeLiteral`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.DefaultTypeAttributeLiteralImpl::Impl as DefaultTypeAttributeLiteralImpl + +/** + * INTERNAL: This module contains the fully generated definition of `DblAttributeLiteral` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::DblAttributeLiteral` class directly. + * Use the subclass `DblAttributeLiteral`, where the following predicates are available. + */ + class DblAttributeLiteral extends Synth::TDblAttributeLiteral, + DefaultTypeAttributeLiteralImpl::DefaultTypeAttributeLiteral + { + override string getAPrimaryQlClass() { result = "DblAttributeLiteral" } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/DblType.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/DblType.qll new file mode 100644 index 000000000000..8b3611a31391 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/DblType.qll @@ -0,0 +1,23 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `DblType`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.XppTypeImpl::Impl as XppTypeImpl + +/** + * INTERNAL: This module contains the fully generated definition of `DblType` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::DblType` class directly. + * Use the subclass `DblType`, where the following predicates are available. + */ + class DblType extends Synth::TDblType, XppTypeImpl::XppType { + override string getAPrimaryQlClass() { result = "DblType" } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/Declaration.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/Declaration.qll new file mode 100644 index 000000000000..18173e8d9017 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/Declaration.qll @@ -0,0 +1,86 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `Declaration`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.ArraySpecification +import codeql.xpp.elements.internal.CompilationUnitImpl::Impl as CompilationUnitImpl +import codeql.xpp.elements.Modifier +import codeql.xpp.elements.XppType + +/** + * INTERNAL: This module contains the fully generated definition of `Declaration` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::Declaration` class directly. + * Use the subclass `Declaration`, where the following predicates are available. + */ + class Declaration extends Synth::TDeclaration, CompilationUnitImpl::CompilationUnit { + /** + * Gets the array specification of this declaration, if it exists. + */ + ArraySpecification getArraySpecification() { + result = + Synth::convertArraySpecificationFromRaw(Synth::convertDeclarationToRaw(this) + .(Raw::Declaration) + .getArraySpecification()) + } + + /** + * Holds if `getArraySpecification()` exists. + */ + final predicate hasArraySpecification() { exists(this.getArraySpecification()) } + + /** + * Gets the `index`th modifier list of this declaration (0-based). + */ + Modifier getModifierList(int index) { + result = + Synth::convertModifierFromRaw(Synth::convertDeclarationToRaw(this) + .(Raw::Declaration) + .getModifierList(index)) + } + + /** + * Gets any of the modifier lists of this declaration. + */ + final Modifier getAModifierList() { result = this.getModifierList(_) } + + /** + * Gets the number of modifier lists of this declaration. + */ + final int getNumberOfModifierLists() { result = count(int i | exists(this.getModifierList(i))) } + + /** + * Gets the modifiers of this declaration, if it exists. + */ + string getModifiers() { + result = Synth::convertDeclarationToRaw(this).(Raw::Declaration).getModifiers() + } + + /** + * Holds if `getModifiers()` exists. + */ + final predicate hasModifiers() { exists(this.getModifiers()) } + + /** + * Gets the type of this declaration, if it exists. + */ + XppType getType() { + result = + Synth::convertXppTypeFromRaw(Synth::convertDeclarationToRaw(this) + .(Raw::Declaration) + .getType()) + } + + /** + * Holds if `getType()` exists. + */ + final predicate hasType() { exists(this.getType()) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/DefaultTypeAttributeLiteral.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/DefaultTypeAttributeLiteral.qll new file mode 100644 index 000000000000..e3416f3709e8 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/DefaultTypeAttributeLiteral.qll @@ -0,0 +1,38 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `DefaultTypeAttributeLiteral`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.AttributeLiteralImpl::Impl as AttributeLiteralImpl + +/** + * INTERNAL: This module contains the fully generated definition of `DefaultTypeAttributeLiteral` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::DefaultTypeAttributeLiteral` class directly. + * Use the subclass `DefaultTypeAttributeLiteral`, where the following predicates are available. + */ + class DefaultTypeAttributeLiteral extends Synth::TDefaultTypeAttributeLiteral, + AttributeLiteralImpl::AttributeLiteral + { + /** + * Gets the scanned literal value of this default type attribute literal, if it exists. + */ + string getScannedLiteralValue() { + result = + Synth::convertDefaultTypeAttributeLiteralToRaw(this) + .(Raw::DefaultTypeAttributeLiteral) + .getScannedLiteralValue() + } + + /** + * Holds if `getScannedLiteralValue()` exists. + */ + final predicate hasScannedLiteralValue() { exists(this.getScannedLiteralValue()) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/DefaultTypeLiteralExpression.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/DefaultTypeLiteralExpression.qll new file mode 100644 index 000000000000..0cbf9ae89253 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/DefaultTypeLiteralExpression.qll @@ -0,0 +1,38 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `DefaultTypeLiteralExpression`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.LiteralExpressionImpl::Impl as LiteralExpressionImpl + +/** + * INTERNAL: This module contains the fully generated definition of `DefaultTypeLiteralExpression` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::DefaultTypeLiteralExpression` class directly. + * Use the subclass `DefaultTypeLiteralExpression`, where the following predicates are available. + */ + class DefaultTypeLiteralExpression extends Synth::TDefaultTypeLiteralExpression, + LiteralExpressionImpl::LiteralExpression + { + /** + * Gets the scanned literal value of this default type literal expression, if it exists. + */ + string getScannedLiteralValue() { + result = + Synth::convertDefaultTypeLiteralExpressionToRaw(this) + .(Raw::DefaultTypeLiteralExpression) + .getScannedLiteralValue() + } + + /** + * Holds if `getScannedLiteralValue()` exists. + */ + final predicate hasScannedLiteralValue() { exists(this.getScannedLiteralValue()) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/Delegate.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/Delegate.qll new file mode 100644 index 000000000000..605412e5b9d9 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/Delegate.qll @@ -0,0 +1,28 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `Delegate`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.MethodOrDelegateImpl::Impl as MethodOrDelegateImpl + +/** + * INTERNAL: This module contains the fully generated definition of `Delegate` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::Delegate` class directly. + * Use the subclass `Delegate`, where the following predicates are available. + */ + class Delegate extends Synth::TDelegate, MethodOrDelegateImpl::MethodOrDelegate { + override string getAPrimaryQlClass() { result = "Delegate" } + + /** + * Holds if this delegate is static. + */ + predicate isStatic() { Synth::convertDelegateToRaw(this).(Raw::Delegate).isStatic() } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/DeleteStatement.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/DeleteStatement.qll new file mode 100644 index 000000000000..c7802a1486be --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/DeleteStatement.qll @@ -0,0 +1,39 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `DeleteStatement`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.Query +import codeql.xpp.elements.internal.StatementImpl::Impl as StatementImpl + +/** + * INTERNAL: This module contains the fully generated definition of `DeleteStatement` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::DeleteStatement` class directly. + * Use the subclass `DeleteStatement`, where the following predicates are available. + */ + class DeleteStatement extends Synth::TDeleteStatement, StatementImpl::Statement { + override string getAPrimaryQlClass() { result = "DeleteStatement" } + + /** + * Gets the query of this delete statement, if it exists. + */ + Query getQuery() { + result = + Synth::convertQueryFromRaw(Synth::convertDeleteStatementToRaw(this) + .(Raw::DeleteStatement) + .getQuery()) + } + + /** + * Holds if `getQuery()` exists. + */ + final predicate hasQuery() { exists(this.getQuery()) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/DivideExpression.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/DivideExpression.qll new file mode 100644 index 000000000000..a6b9333533fb --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/DivideExpression.qll @@ -0,0 +1,23 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `DivideExpression`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.BinaryExpressionImpl::Impl as BinaryExpressionImpl + +/** + * INTERNAL: This module contains the fully generated definition of `DivideExpression` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::DivideExpression` class directly. + * Use the subclass `DivideExpression`, where the following predicates are available. + */ + class DivideExpression extends Synth::TDivideExpression, BinaryExpressionImpl::BinaryExpression { + override string getAPrimaryQlClass() { result = "DivideExpression" } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/DoWhileStatement.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/DoWhileStatement.qll new file mode 100644 index 000000000000..fbb371a0dcc6 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/DoWhileStatement.qll @@ -0,0 +1,55 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `DoWhileStatement`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.Expression +import codeql.xpp.elements.Statement +import codeql.xpp.elements.internal.StatementImpl::Impl as StatementImpl + +/** + * INTERNAL: This module contains the fully generated definition of `DoWhileStatement` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::DoWhileStatement` class directly. + * Use the subclass `DoWhileStatement`, where the following predicates are available. + */ + class DoWhileStatement extends Synth::TDoWhileStatement, StatementImpl::Statement { + override string getAPrimaryQlClass() { result = "DoWhileStatement" } + + /** + * Gets the condition of this do while statement, if it exists. + */ + Expression getCondition() { + result = + Synth::convertExpressionFromRaw(Synth::convertDoWhileStatementToRaw(this) + .(Raw::DoWhileStatement) + .getCondition()) + } + + /** + * Holds if `getCondition()` exists. + */ + final predicate hasCondition() { exists(this.getCondition()) } + + /** + * Gets the statement of this do while statement, if it exists. + */ + Statement getStatement() { + result = + Synth::convertStatementFromRaw(Synth::convertDoWhileStatementToRaw(this) + .(Raw::DoWhileStatement) + .getStatement()) + } + + /** + * Holds if `getStatement()` exists. + */ + final predicate hasStatement() { exists(this.getStatement()) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/Element.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/Element.qll new file mode 100644 index 000000000000..719d95da181a --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/Element.qll @@ -0,0 +1,77 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `Element`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.Element + +private class ElementAlias = Element; + +/** + * INTERNAL: This module contains the fully generated definition of `Element` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::Element` class directly. + * Use the subclass `Element`, where the following predicates are available. + */ + class Element extends Synth::TElement { + /** + * Gets the string representation of this element. + */ + cached + final string toString() { + result = this.toStringImpl() and + // recursion guard to prevent `toString` from being defined recursively + (exists(any(Element e).toStringImpl()) implies any()) + } + + /** + * INTERNAL: Do not use. + * + * Gets the string representation of this element. + */ + abstract string toStringImpl(); + + /** + * Gets the name of a primary CodeQL class to which this element belongs. + * + * This is the most precise syntactic category to which they belong; for + * example, `CallExpr` is a primary class, but `ApplyExpr` is not. + * + * There might be some corner cases when this returns multiple classes, or none. + */ + string getAPrimaryQlClass() { none() } // overridden by subclasses + + /** + * Gets a comma-separated list of the names of the primary CodeQL classes to which this element belongs. + */ + final string getPrimaryQlClasses() { result = concat(this.getAPrimaryQlClass(), ",") } + + /** + * Gets the most immediate element that should substitute this element in the explicit AST, if any. + * Classes can override this to indicate this node should be in the "hidden" AST, mostly reserved + * for conversions and syntactic sugar nodes like parentheses. + */ + ElementAlias getResolveStep() { none() } // overridden by subclasses + + /** + * Gets the element that should substitute this element in the explicit AST, applying `getResolveStep` + * transitively. + */ + final ElementAlias resolve() { + not exists(this.getResolveStep()) and result = this + or + result = this.getResolveStep().resolve() + } + + /** + * Holds if this element is unknown. + */ + predicate isUnknown() { Synth::convertElementToRaw(this).isUnknown() } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/EmptyExpression.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/EmptyExpression.qll new file mode 100644 index 000000000000..bb62d4cc9e89 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/EmptyExpression.qll @@ -0,0 +1,23 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `EmptyExpression`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.ExpressionImpl::Impl as ExpressionImpl + +/** + * INTERNAL: This module contains the fully generated definition of `EmptyExpression` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::EmptyExpression` class directly. + * Use the subclass `EmptyExpression`, where the following predicates are available. + */ + class EmptyExpression extends Synth::TEmptyExpression, ExpressionImpl::Expression { + override string getAPrimaryQlClass() { result = "EmptyExpression" } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/EmptyStatement.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/EmptyStatement.qll new file mode 100644 index 000000000000..e7a9495728fc --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/EmptyStatement.qll @@ -0,0 +1,23 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `EmptyStatement`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.StatementImpl::Impl as StatementImpl + +/** + * INTERNAL: This module contains the fully generated definition of `EmptyStatement` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::EmptyStatement` class directly. + * Use the subclass `EmptyStatement`, where the following predicates are available. + */ + class EmptyStatement extends Synth::TEmptyStatement, StatementImpl::Statement { + override string getAPrimaryQlClass() { result = "EmptyStatement" } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/EnumAttributeLiteral.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/EnumAttributeLiteral.qll new file mode 100644 index 000000000000..b359c33e64a7 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/EnumAttributeLiteral.qll @@ -0,0 +1,51 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `EnumAttributeLiteral`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.AttributeLiteralImpl::Impl as AttributeLiteralImpl + +/** + * INTERNAL: This module contains the fully generated definition of `EnumAttributeLiteral` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::EnumAttributeLiteral` class directly. + * Use the subclass `EnumAttributeLiteral`, where the following predicates are available. + */ + class EnumAttributeLiteral extends Synth::TEnumAttributeLiteral, + AttributeLiteralImpl::AttributeLiteral + { + override string getAPrimaryQlClass() { result = "EnumAttributeLiteral" } + + /** + * Gets the literal of this enum attribute literal, if it exists. + */ + string getLiteral() { + result = + Synth::convertEnumAttributeLiteralToRaw(this).(Raw::EnumAttributeLiteral).getLiteral() + } + + /** + * Holds if `getLiteral()` exists. + */ + final predicate hasLiteral() { exists(this.getLiteral()) } + + /** + * Gets the type name of this enum attribute literal, if it exists. + */ + string getTypeName() { + result = + Synth::convertEnumAttributeLiteralToRaw(this).(Raw::EnumAttributeLiteral).getTypeName() + } + + /** + * Holds if `getTypeName()` exists. + */ + final predicate hasTypeName() { exists(this.getTypeName()) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/EnumerationLiteralExpression.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/EnumerationLiteralExpression.qll new file mode 100644 index 000000000000..773536015b03 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/EnumerationLiteralExpression.qll @@ -0,0 +1,55 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `EnumerationLiteralExpression`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.LiteralExpressionImpl::Impl as LiteralExpressionImpl + +/** + * INTERNAL: This module contains the fully generated definition of `EnumerationLiteralExpression` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::EnumerationLiteralExpression` class directly. + * Use the subclass `EnumerationLiteralExpression`, where the following predicates are available. + */ + class EnumerationLiteralExpression extends Synth::TEnumerationLiteralExpression, + LiteralExpressionImpl::LiteralExpression + { + override string getAPrimaryQlClass() { result = "EnumerationLiteralExpression" } + + /** + * Gets the enumeration literal of this enumeration literal expression, if it exists. + */ + string getEnumerationLiteral() { + result = + Synth::convertEnumerationLiteralExpressionToRaw(this) + .(Raw::EnumerationLiteralExpression) + .getEnumerationLiteral() + } + + /** + * Holds if `getEnumerationLiteral()` exists. + */ + final predicate hasEnumerationLiteral() { exists(this.getEnumerationLiteral()) } + + /** + * Gets the enumeration type of this enumeration literal expression, if it exists. + */ + string getEnumerationType() { + result = + Synth::convertEnumerationLiteralExpressionToRaw(this) + .(Raw::EnumerationLiteralExpression) + .getEnumerationType() + } + + /** + * Holds if `getEnumerationType()` exists. + */ + final predicate hasEnumerationType() { exists(this.getEnumerationType()) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/EnumerationType.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/EnumerationType.qll new file mode 100644 index 000000000000..3818834494b5 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/EnumerationType.qll @@ -0,0 +1,59 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `EnumerationType`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.XppTypeImpl::Impl as XppTypeImpl + +/** + * INTERNAL: This module contains the fully generated definition of `EnumerationType` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::EnumerationType` class directly. + * Use the subclass `EnumerationType`, where the following predicates are available. + */ + class EnumerationType extends Synth::TEnumerationType, XppTypeImpl::XppType { + override string getAPrimaryQlClass() { result = "EnumerationType" } + + /** + * Gets the enumerated type of this enumeration type, if it exists. + */ + string getEnumeratedType() { + result = Synth::convertEnumerationTypeToRaw(this).(Raw::EnumerationType).getEnumeratedType() + } + + /** + * Holds if `getEnumeratedType()` exists. + */ + final predicate hasEnumeratedType() { exists(this.getEnumeratedType()) } + + /** + * Gets the full name of this enumeration type, if it exists. + */ + string getFullName() { + result = Synth::convertEnumerationTypeToRaw(this).(Raw::EnumerationType).getFullName() + } + + /** + * Holds if `getFullName()` exists. + */ + final predicate hasFullName() { exists(this.getFullName()) } + + /** + * Gets the namespace of this enumeration type, if it exists. + */ + string getNamespace() { + result = Synth::convertEnumerationTypeToRaw(this).(Raw::EnumerationType).getNamespace() + } + + /** + * Holds if `getNamespace()` exists. + */ + final predicate hasNamespace() { exists(this.getNamespace()) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/EqualExpression.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/EqualExpression.qll new file mode 100644 index 000000000000..1650906189b2 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/EqualExpression.qll @@ -0,0 +1,25 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `EqualExpression`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.RelationalExpressionImpl::Impl as RelationalExpressionImpl + +/** + * INTERNAL: This module contains the fully generated definition of `EqualExpression` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::EqualExpression` class directly. + * Use the subclass `EqualExpression`, where the following predicates are available. + */ + class EqualExpression extends Synth::TEqualExpression, + RelationalExpressionImpl::RelationalExpression + { + override string getAPrimaryQlClass() { result = "EqualExpression" } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/ErrorElement.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/ErrorElement.qll new file mode 100644 index 000000000000..1ce689be7119 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/ErrorElement.qll @@ -0,0 +1,22 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `ErrorElement`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.LocatableImpl::Impl as LocatableImpl + +/** + * INTERNAL: This module contains the fully generated definition of `ErrorElement` and should not + * be referenced directly. + */ +module Generated { + /** + * The superclass of all elements indicating some kind of error. + * INTERNAL: Do not reference the `Generated::ErrorElement` class directly. + * Use the subclass `ErrorElement`, where the following predicates are available. + */ + class ErrorElement extends Synth::TErrorElement, LocatableImpl::Locatable { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/Evaluation.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/Evaluation.qll new file mode 100644 index 000000000000..acf64b60bd84 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/Evaluation.qll @@ -0,0 +1,46 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `Evaluation`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.EvaluationActualParameterEntry +import codeql.xpp.elements.internal.ExpressionImpl::Impl as ExpressionImpl + +/** + * INTERNAL: This module contains the fully generated definition of `Evaluation` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::Evaluation` class directly. + * Use the subclass `Evaluation`, where the following predicates are available. + */ + class Evaluation extends Synth::TEvaluation, ExpressionImpl::Expression { + /** + * Gets the `index`th actual parameter of this evaluation (0-based). + */ + EvaluationActualParameterEntry getActualParameter(int index) { + result = + Synth::convertEvaluationActualParameterEntryFromRaw(Synth::convertEvaluationToRaw(this) + .(Raw::Evaluation) + .getActualParameter(index)) + } + + /** + * Gets any of the actual parameters of this evaluation. + */ + final EvaluationActualParameterEntry getAnActualParameter() { + result = this.getActualParameter(_) + } + + /** + * Gets the number of actual parameters of this evaluation. + */ + final int getNumberOfActualParameters() { + result = count(int i | exists(this.getActualParameter(i))) + } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/EvaluationActualParameterEntry.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/EvaluationActualParameterEntry.qll new file mode 100644 index 000000000000..cbf500d33f67 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/EvaluationActualParameterEntry.qll @@ -0,0 +1,50 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `EvaluationActualParameterEntry`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.Expression +import codeql.xpp.elements.internal.XppTupleImpl::Impl as XppTupleImpl + +/** + * INTERNAL: This module contains the fully generated definition of `EvaluationActualParameterEntry` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::EvaluationActualParameterEntry` class directly. + * Use the subclass `EvaluationActualParameterEntry`, where the following predicates are available. + */ + class EvaluationActualParameterEntry extends Synth::TEvaluationActualParameterEntry, + XppTupleImpl::XppTuple + { + override string getAPrimaryQlClass() { result = "EvaluationActualParameterEntry" } + + /** + * Holds if this evaluation actual parameter entry item1. + */ + predicate item1() { + Synth::convertEvaluationActualParameterEntryToRaw(this) + .(Raw::EvaluationActualParameterEntry) + .item1() + } + + /** + * Gets the expression of this evaluation actual parameter entry, if it exists. + */ + Expression getExpression() { + result = + Synth::convertExpressionFromRaw(Synth::convertEvaluationActualParameterEntryToRaw(this) + .(Raw::EvaluationActualParameterEntry) + .getExpression()) + } + + /** + * Holds if `getExpression()` exists. + */ + final predicate hasExpression() { exists(this.getExpression()) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/ExplicitSelection.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/ExplicitSelection.qll new file mode 100644 index 000000000000..e8ffb8446ef0 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/ExplicitSelection.qll @@ -0,0 +1,44 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `ExplicitSelection`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.SelectionField +import codeql.xpp.elements.internal.SelectionImpl::Impl as SelectionImpl + +/** + * INTERNAL: This module contains the fully generated definition of `ExplicitSelection` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::ExplicitSelection` class directly. + * Use the subclass `ExplicitSelection`, where the following predicates are available. + */ + class ExplicitSelection extends Synth::TExplicitSelection, SelectionImpl::Selection { + override string getAPrimaryQlClass() { result = "ExplicitSelection" } + + /** + * Gets the `index`th field of this explicit selection (0-based). + */ + SelectionField getField(int index) { + result = + Synth::convertSelectionFieldFromRaw(Synth::convertExplicitSelectionToRaw(this) + .(Raw::ExplicitSelection) + .getField(index)) + } + + /** + * Gets any of the fields of this explicit selection. + */ + final SelectionField getAField() { result = this.getField(_) } + + /** + * Gets the number of fields of this explicit selection. + */ + final int getNumberOfFields() { result = count(int i | exists(this.getField(i))) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/Expression.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/Expression.qll new file mode 100644 index 000000000000..2368f371c896 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/Expression.qll @@ -0,0 +1,44 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `Expression`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.AstImpl::Impl as AstImpl +import codeql.xpp.elements.Expression + +private class ExpressionAlias = Expression; + +/** + * INTERNAL: This module contains the fully generated definition of `Expression` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::Expression` class directly. + * Use the subclass `Expression`, where the following predicates are available. + */ + class Expression extends Synth::TExpression, AstImpl::Ast { + /** + * Holds if this expression is const. + */ + predicate isConst() { Synth::convertExpressionToRaw(this).(Raw::Expression).isConst() } + + /** + * Gets the transformation of this expression, if it exists. + */ + ExpressionAlias getTransformation() { + result = + Synth::convertExpressionFromRaw(Synth::convertExpressionToRaw(this) + .(Raw::Expression) + .getTransformation()) + } + + /** + * Holds if `getTransformation()` exists. + */ + final predicate hasTransformation() { exists(this.getTransformation()) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/ExpressionCompilationUnit.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/ExpressionCompilationUnit.qll new file mode 100644 index 000000000000..3531a89416ef --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/ExpressionCompilationUnit.qll @@ -0,0 +1,56 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `ExpressionCompilationUnit`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.CompilationUnitImpl::Impl as CompilationUnitImpl +import codeql.xpp.elements.Expression + +/** + * INTERNAL: This module contains the fully generated definition of `ExpressionCompilationUnit` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::ExpressionCompilationUnit` class directly. + * Use the subclass `ExpressionCompilationUnit`, where the following predicates are available. + */ + class ExpressionCompilationUnit extends Synth::TExpressionCompilationUnit, + CompilationUnitImpl::CompilationUnit + { + override string getAPrimaryQlClass() { result = "ExpressionCompilationUnit" } + + /** + * Gets the expression of this expression compilation unit, if it exists. + */ + Expression getExpression() { + result = + Synth::convertExpressionFromRaw(Synth::convertExpressionCompilationUnitToRaw(this) + .(Raw::ExpressionCompilationUnit) + .getExpression()) + } + + /** + * Holds if `getExpression()` exists. + */ + final predicate hasExpression() { exists(this.getExpression()) } + + /** + * Gets the path contribution of this expression compilation unit, if it exists. + */ + string getPathContribution() { + result = + Synth::convertExpressionCompilationUnitToRaw(this) + .(Raw::ExpressionCompilationUnit) + .getPathContribution() + } + + /** + * Holds if `getPathContribution()` exists. + */ + final predicate hasPathContribution() { exists(this.getPathContribution()) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/ExpressionQualifier.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/ExpressionQualifier.qll new file mode 100644 index 000000000000..423d337ca243 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/ExpressionQualifier.qll @@ -0,0 +1,39 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `ExpressionQualifier`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.Expression +import codeql.xpp.elements.internal.QualifierImpl::Impl as QualifierImpl + +/** + * INTERNAL: This module contains the fully generated definition of `ExpressionQualifier` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::ExpressionQualifier` class directly. + * Use the subclass `ExpressionQualifier`, where the following predicates are available. + */ + class ExpressionQualifier extends Synth::TExpressionQualifier, QualifierImpl::Qualifier { + override string getAPrimaryQlClass() { result = "ExpressionQualifier" } + + /** + * Gets the expression of this expression qualifier, if it exists. + */ + Expression getExpression() { + result = + Synth::convertExpressionFromRaw(Synth::convertExpressionQualifierToRaw(this) + .(Raw::ExpressionQualifier) + .getExpression()) + } + + /** + * Holds if `getExpression()` exists. + */ + final predicate hasExpression() { exists(this.getExpression()) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/ExpressionStatement.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/ExpressionStatement.qll new file mode 100644 index 000000000000..ef87daf3130c --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/ExpressionStatement.qll @@ -0,0 +1,52 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `ExpressionStatement`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.Expression +import codeql.xpp.elements.internal.StatementImpl::Impl as StatementImpl + +/** + * INTERNAL: This module contains the fully generated definition of `ExpressionStatement` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::ExpressionStatement` class directly. + * Use the subclass `ExpressionStatement`, where the following predicates are available. + */ + class ExpressionStatement extends Synth::TExpressionStatement, StatementImpl::Statement { + override string getAPrimaryQlClass() { result = "ExpressionStatement" } + + /** + * Gets the element type name of this expression statement, if it exists. + */ + string getElementTypeName() { + result = + Synth::convertExpressionStatementToRaw(this).(Raw::ExpressionStatement).getElementTypeName() + } + + /** + * Holds if `getElementTypeName()` exists. + */ + final predicate hasElementTypeName() { exists(this.getElementTypeName()) } + + /** + * Gets the expression of this expression statement, if it exists. + */ + Expression getExpression() { + result = + Synth::convertExpressionFromRaw(Synth::convertExpressionStatementToRaw(this) + .(Raw::ExpressionStatement) + .getExpression()) + } + + /** + * Holds if `getExpression()` exists. + */ + final predicate hasExpression() { exists(this.getExpression()) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/FieldAssignment.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/FieldAssignment.qll new file mode 100644 index 000000000000..377a3eda2db9 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/FieldAssignment.qll @@ -0,0 +1,75 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `FieldAssignment`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.AstImpl::Impl as AstImpl +import codeql.xpp.elements.Expression + +/** + * INTERNAL: This module contains the fully generated definition of `FieldAssignment` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::FieldAssignment` class directly. + * Use the subclass `FieldAssignment`, where the following predicates are available. + */ + class FieldAssignment extends Synth::TFieldAssignment, AstImpl::Ast { + override string getAPrimaryQlClass() { result = "FieldAssignment" } + + /** + * Gets the expression of this field assignment, if it exists. + */ + Expression getExpression() { + result = + Synth::convertExpressionFromRaw(Synth::convertFieldAssignmentToRaw(this) + .(Raw::FieldAssignment) + .getExpression()) + } + + /** + * Holds if `getExpression()` exists. + */ + final predicate hasExpression() { exists(this.getExpression()) } + + /** + * Gets the extension name of this field assignment, if it exists. + */ + string getExtensionName() { + result = Synth::convertFieldAssignmentToRaw(this).(Raw::FieldAssignment).getExtensionName() + } + + /** + * Holds if `getExtensionName()` exists. + */ + final predicate hasExtensionName() { exists(this.getExtensionName()) } + + /** + * Gets the field name of this field assignment, if it exists. + */ + string getFieldName() { + result = Synth::convertFieldAssignmentToRaw(this).(Raw::FieldAssignment).getFieldName() + } + + /** + * Holds if `getFieldName()` exists. + */ + final predicate hasFieldName() { exists(this.getFieldName()) } + + /** + * Gets the index of this field assignment, if it exists. + */ + int getIndex() { + result = Synth::convertFieldAssignmentToRaw(this).(Raw::FieldAssignment).getIndex() + } + + /** + * Holds if `getIndex()` exists. + */ + final predicate hasIndex() { exists(this.getIndex()) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/FieldDeclaration.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/FieldDeclaration.qll new file mode 100644 index 000000000000..0fd9f69a10ee --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/FieldDeclaration.qll @@ -0,0 +1,141 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `FieldDeclaration`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.AttributeList +import codeql.xpp.elements.internal.DeclarationImpl::Impl as DeclarationImpl +import codeql.xpp.elements.Expression + +/** + * INTERNAL: This module contains the fully generated definition of `FieldDeclaration` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::FieldDeclaration` class directly. + * Use the subclass `FieldDeclaration`, where the following predicates are available. + */ + class FieldDeclaration extends Synth::TFieldDeclaration, DeclarationImpl::Declaration { + /** + * Gets the attributes of this field declaration, if it exists. + */ + AttributeList getAttributes() { + result = + Synth::convertAttributeListFromRaw(Synth::convertFieldDeclarationToRaw(this) + .(Raw::FieldDeclaration) + .getAttributes()) + } + + /** + * Holds if `getAttributes()` exists. + */ + final predicate hasAttributes() { exists(this.getAttributes()) } + + /** + * Gets the element type name of this field declaration, if it exists. + */ + string getElementTypeName() { + result = + Synth::convertFieldDeclarationToRaw(this).(Raw::FieldDeclaration).getElementTypeName() + } + + /** + * Holds if `getElementTypeName()` exists. + */ + final predicate hasElementTypeName() { exists(this.getElementTypeName()) } + + /** + * Gets the extension name of this field declaration, if it exists. + */ + string getExtensionName() { + result = Synth::convertFieldDeclarationToRaw(this).(Raw::FieldDeclaration).getExtensionName() + } + + /** + * Holds if `getExtensionName()` exists. + */ + final predicate hasExtensionName() { exists(this.getExtensionName()) } + + /** + * Gets the initial value of this field declaration, if it exists. + */ + Expression getInitialValue() { + result = + Synth::convertExpressionFromRaw(Synth::convertFieldDeclarationToRaw(this) + .(Raw::FieldDeclaration) + .getInitialValue()) + } + + /** + * Holds if `getInitialValue()` exists. + */ + final predicate hasInitialValue() { exists(this.getInitialValue()) } + + /** + * Holds if this field declaration is const. + */ + predicate isConst() { + Synth::convertFieldDeclarationToRaw(this).(Raw::FieldDeclaration).isConst() + } + + /** + * Holds if this field declaration is extension. + */ + predicate isExtension() { + Synth::convertFieldDeclarationToRaw(this).(Raw::FieldDeclaration).isExtension() + } + + /** + * Holds if this field declaration is internal. + */ + predicate isInternal() { + Synth::convertFieldDeclarationToRaw(this).(Raw::FieldDeclaration).isInternal() + } + + /** + * Holds if this field declaration is obsolete. + */ + predicate isObsolete() { + Synth::convertFieldDeclarationToRaw(this).(Raw::FieldDeclaration).isObsolete() + } + + /** + * Holds if this field declaration is private. + */ + predicate isPrivate() { + Synth::convertFieldDeclarationToRaw(this).(Raw::FieldDeclaration).isPrivate() + } + + /** + * Holds if this field declaration is protected. + */ + predicate isProtected() { + Synth::convertFieldDeclarationToRaw(this).(Raw::FieldDeclaration).isProtected() + } + + /** + * Holds if this field declaration is public. + */ + predicate isPublic() { + Synth::convertFieldDeclarationToRaw(this).(Raw::FieldDeclaration).isPublic() + } + + /** + * Holds if this field declaration is read only. + */ + predicate isReadOnly() { + Synth::convertFieldDeclarationToRaw(this).(Raw::FieldDeclaration).isReadOnly() + } + + /** + * Holds if this field declaration is static. + */ + predicate isStatic() { + Synth::convertFieldDeclarationToRaw(this).(Raw::FieldDeclaration).isStatic() + } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/FieldDeclarationInternal.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/FieldDeclarationInternal.qll new file mode 100644 index 000000000000..222d99ebd01b --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/FieldDeclarationInternal.qll @@ -0,0 +1,25 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `FieldDeclarationInternal`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.FieldDeclarationImpl::Impl as FieldDeclarationImpl + +/** + * INTERNAL: This module contains the fully generated definition of `FieldDeclarationInternal` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::FieldDeclarationInternal` class directly. + * Use the subclass `FieldDeclarationInternal`, where the following predicates are available. + */ + class FieldDeclarationInternal extends Synth::TFieldDeclarationInternal, + FieldDeclarationImpl::FieldDeclaration + { + override string getAPrimaryQlClass() { result = "FieldDeclarationInternal" } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/FieldExpression.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/FieldExpression.qll new file mode 100644 index 000000000000..88ee003bcde1 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/FieldExpression.qll @@ -0,0 +1,42 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `FieldExpression`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.ExpressionImpl::Impl as ExpressionImpl +import codeql.xpp.elements.FieldSpecification + +/** + * INTERNAL: This module contains the fully generated definition of `FieldExpression` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::FieldExpression` class directly. + * Use the subclass `FieldExpression`, where the following predicates are available. + */ + class FieldExpression extends Synth::TFieldExpression, ExpressionImpl::Expression { + /** + * Gets the field of this field expression, if it exists. + */ + FieldSpecification getField() { + result = + Synth::convertFieldSpecificationFromRaw(Synth::convertFieldExpressionToRaw(this) + .(Raw::FieldExpression) + .getField()) + } + + /** + * Holds if `getField()` exists. + */ + final predicate hasField() { exists(this.getField()) } + + /** + * Holds if this field expression is enum. + */ + predicate isEnum() { Synth::convertFieldExpressionToRaw(this).(Raw::FieldExpression).isEnum() } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/FieldExpressionInternal.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/FieldExpressionInternal.qll new file mode 100644 index 000000000000..d8beef4d0362 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/FieldExpressionInternal.qll @@ -0,0 +1,25 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `FieldExpressionInternal`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.FieldExpressionImpl::Impl as FieldExpressionImpl + +/** + * INTERNAL: This module contains the fully generated definition of `FieldExpressionInternal` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::FieldExpressionInternal` class directly. + * Use the subclass `FieldExpressionInternal`, where the following predicates are available. + */ + class FieldExpressionInternal extends Synth::TFieldExpressionInternal, + FieldExpressionImpl::FieldExpression + { + override string getAPrimaryQlClass() { result = "FieldExpressionInternal" } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/FieldSelection.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/FieldSelection.qll new file mode 100644 index 000000000000..078563e23aef --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/FieldSelection.qll @@ -0,0 +1,35 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `FieldSelection`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.SelectionFieldImpl::Impl as SelectionFieldImpl + +/** + * INTERNAL: This module contains the fully generated definition of `FieldSelection` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::FieldSelection` class directly. + * Use the subclass `FieldSelection`, where the following predicates are available. + */ + class FieldSelection extends Synth::TFieldSelection, SelectionFieldImpl::SelectionField { + override string getAPrimaryQlClass() { result = "FieldSelection" } + + /** + * Gets the index of this field selection, if it exists. + */ + int getIndex() { + result = Synth::convertFieldSelectionToRaw(this).(Raw::FieldSelection).getIndex() + } + + /** + * Holds if `getIndex()` exists. + */ + final predicate hasIndex() { exists(this.getIndex()) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/FieldSpecification.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/FieldSpecification.qll new file mode 100644 index 000000000000..7a98d7be6877 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/FieldSpecification.qll @@ -0,0 +1,115 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `FieldSpecification`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.AstImpl::Impl as AstImpl +import codeql.xpp.elements.Expression +import codeql.xpp.elements.Qualifier + +/** + * INTERNAL: This module contains the fully generated definition of `FieldSpecification` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::FieldSpecification` class directly. + * Use the subclass `FieldSpecification`, where the following predicates are available. + */ + class FieldSpecification extends Synth::TFieldSpecification, AstImpl::Ast { + /** + * Gets the array index of this field specification, if it exists. + */ + Expression getArrayIndex() { + result = + Synth::convertExpressionFromRaw(Synth::convertFieldSpecificationToRaw(this) + .(Raw::FieldSpecification) + .getArrayIndex()) + } + + /** + * Holds if `getArrayIndex()` exists. + */ + final predicate hasArrayIndex() { exists(this.getArrayIndex()) } + + /** + * Gets the element type name of this field specification, if it exists. + */ + string getElementTypeName() { + result = + Synth::convertFieldSpecificationToRaw(this).(Raw::FieldSpecification).getElementTypeName() + } + + /** + * Holds if `getElementTypeName()` exists. + */ + final predicate hasElementTypeName() { exists(this.getElementTypeName()) } + + /** + * Holds if this field specification is const. + */ + predicate isConst() { + Synth::convertFieldSpecificationToRaw(this).(Raw::FieldSpecification).isConst() + } + + /** + * Holds if this field specification is internal. + */ + predicate isInternal() { + Synth::convertFieldSpecificationToRaw(this).(Raw::FieldSpecification).isInternal() + } + + /** + * Holds if this field specification is private. + */ + predicate isPrivate() { + Synth::convertFieldSpecificationToRaw(this).(Raw::FieldSpecification).isPrivate() + } + + /** + * Holds if this field specification is protected. + */ + predicate isProtected() { + Synth::convertFieldSpecificationToRaw(this).(Raw::FieldSpecification).isProtected() + } + + /** + * Holds if this field specification is public. + */ + predicate isPublic() { + Synth::convertFieldSpecificationToRaw(this).(Raw::FieldSpecification).isPublic() + } + + /** + * Holds if this field specification is read only. + */ + predicate isReadOnly() { + Synth::convertFieldSpecificationToRaw(this).(Raw::FieldSpecification).isReadOnly() + } + + /** + * Holds if this field specification is static. + */ + predicate isStatic() { + Synth::convertFieldSpecificationToRaw(this).(Raw::FieldSpecification).isStatic() + } + + /** + * Gets the qualifier of this field specification, if it exists. + */ + Qualifier getQualifier() { + result = + Synth::convertQualifierFromRaw(Synth::convertFieldSpecificationToRaw(this) + .(Raw::FieldSpecification) + .getQualifier()) + } + + /** + * Holds if `getQualifier()` exists. + */ + final predicate hasQualifier() { exists(this.getQualifier()) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/File.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/File.qll new file mode 100644 index 000000000000..e49ce5a159e3 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/File.qll @@ -0,0 +1,28 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `File`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.ElementImpl::Impl as ElementImpl + +/** + * INTERNAL: This module contains the fully generated definition of `File` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::File` class directly. + * Use the subclass `File`, where the following predicates are available. + */ + class File extends Synth::TFile, ElementImpl::Element { + override string getAPrimaryQlClass() { result = "File" } + + /** + * Gets the name of this file. + */ + string getName() { result = Synth::convertFileToRaw(this).(Raw::File).getName() } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/FindStatement.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/FindStatement.qll new file mode 100644 index 000000000000..8cab17ba243f --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/FindStatement.qll @@ -0,0 +1,39 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `FindStatement`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.Query +import codeql.xpp.elements.internal.StatementImpl::Impl as StatementImpl + +/** + * INTERNAL: This module contains the fully generated definition of `FindStatement` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::FindStatement` class directly. + * Use the subclass `FindStatement`, where the following predicates are available. + */ + class FindStatement extends Synth::TFindStatement, StatementImpl::Statement { + override string getAPrimaryQlClass() { result = "FindStatement" } + + /** + * Gets the query of this find statement, if it exists. + */ + Query getQuery() { + result = + Synth::convertQueryFromRaw(Synth::convertFindStatementToRaw(this) + .(Raw::FindStatement) + .getQuery()) + } + + /** + * Holds if `getQuery()` exists. + */ + final predicate hasQuery() { exists(this.getQuery()) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/FlushStatement.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/FlushStatement.qll new file mode 100644 index 000000000000..dd9dad392a12 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/FlushStatement.qll @@ -0,0 +1,40 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `FlushStatement`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.StatementImpl::Impl as StatementImpl + +/** + * INTERNAL: This module contains the fully generated definition of `FlushStatement` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::FlushStatement` class directly. + * Use the subclass `FlushStatement`, where the following predicates are available. + */ + class FlushStatement extends Synth::TFlushStatement, StatementImpl::Statement { + override string getAPrimaryQlClass() { result = "FlushStatement" } + + /** + * Gets the `index`th id list of this flush statement (0-based). + */ + string getIdList(int index) { + result = Synth::convertFlushStatementToRaw(this).(Raw::FlushStatement).getIdList(index) + } + + /** + * Gets any of the id lists of this flush statement. + */ + final string getAnIdList() { result = this.getIdList(_) } + + /** + * Gets the number of id lists of this flush statement. + */ + final int getNumberOfIdLists() { result = count(int i | exists(this.getIdList(i))) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/ForAssign.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/ForAssign.qll new file mode 100644 index 000000000000..7ea4f30b6634 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/ForAssign.qll @@ -0,0 +1,37 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `ForAssign`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.AstImpl::Impl as AstImpl +import codeql.xpp.elements.FieldSpecification + +/** + * INTERNAL: This module contains the fully generated definition of `ForAssign` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::ForAssign` class directly. + * Use the subclass `ForAssign`, where the following predicates are available. + */ + class ForAssign extends Synth::TForAssign, AstImpl::Ast { + /** + * Gets the field specification of this for assign, if it exists. + */ + FieldSpecification getFieldSpecification() { + result = + Synth::convertFieldSpecificationFromRaw(Synth::convertForAssignToRaw(this) + .(Raw::ForAssign) + .getFieldSpecification()) + } + + /** + * Holds if `getFieldSpecification()` exists. + */ + final predicate hasFieldSpecification() { exists(this.getFieldSpecification()) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/ForDeclarationAssign.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/ForDeclarationAssign.qll new file mode 100644 index 000000000000..6455e3dc36c6 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/ForDeclarationAssign.qll @@ -0,0 +1,48 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `ForDeclarationAssign`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.ForAssignImpl::Impl as ForAssignImpl +import codeql.xpp.elements.VariableDeclaration + +/** + * INTERNAL: This module contains the fully generated definition of `ForDeclarationAssign` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::ForDeclarationAssign` class directly. + * Use the subclass `ForDeclarationAssign`, where the following predicates are available. + */ + class ForDeclarationAssign extends Synth::TForDeclarationAssign, ForAssignImpl::ForAssign { + override string getAPrimaryQlClass() { result = "ForDeclarationAssign" } + + /** + * Gets the `index`th initialization declaration of this for declaration assign (0-based). + */ + VariableDeclaration getInitializationDeclaration(int index) { + result = + Synth::convertVariableDeclarationFromRaw(Synth::convertForDeclarationAssignToRaw(this) + .(Raw::ForDeclarationAssign) + .getInitializationDeclaration(index)) + } + + /** + * Gets any of the initialization declarations of this for declaration assign. + */ + final VariableDeclaration getAnInitializationDeclaration() { + result = this.getInitializationDeclaration(_) + } + + /** + * Gets the number of initialization declarations of this for declaration assign. + */ + final int getNumberOfInitializationDeclarations() { + result = count(int i | exists(this.getInitializationDeclaration(i))) + } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/ForExpressionAssign.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/ForExpressionAssign.qll new file mode 100644 index 000000000000..325ffcfd2050 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/ForExpressionAssign.qll @@ -0,0 +1,37 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `ForExpressionAssign`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.Expression +import codeql.xpp.elements.internal.ForAssignImpl::Impl as ForAssignImpl + +/** + * INTERNAL: This module contains the fully generated definition of `ForExpressionAssign` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::ForExpressionAssign` class directly. + * Use the subclass `ForExpressionAssign`, where the following predicates are available. + */ + class ForExpressionAssign extends Synth::TForExpressionAssign, ForAssignImpl::ForAssign { + /** + * Gets the expression of this for expression assign, if it exists. + */ + Expression getExpression() { + result = + Synth::convertExpressionFromRaw(Synth::convertForExpressionAssignToRaw(this) + .(Raw::ForExpressionAssign) + .getExpression()) + } + + /** + * Holds if `getExpression()` exists. + */ + final predicate hasExpression() { exists(this.getExpression()) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/ForFieldAssign.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/ForFieldAssign.qll new file mode 100644 index 000000000000..8d12e0370cdd --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/ForFieldAssign.qll @@ -0,0 +1,23 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `ForFieldAssign`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.ForExpressionAssignImpl::Impl as ForExpressionAssignImpl + +/** + * INTERNAL: This module contains the fully generated definition of `ForFieldAssign` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::ForFieldAssign` class directly. + * Use the subclass `ForFieldAssign`, where the following predicates are available. + */ + class ForFieldAssign extends Synth::TForFieldAssign, ForExpressionAssignImpl::ForExpressionAssign { + override string getAPrimaryQlClass() { result = "ForFieldAssign" } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/ForFieldDecrementAssign.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/ForFieldDecrementAssign.qll new file mode 100644 index 000000000000..769f171b7219 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/ForFieldDecrementAssign.qll @@ -0,0 +1,25 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `ForFieldDecrementAssign`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.ForExpressionAssignImpl::Impl as ForExpressionAssignImpl + +/** + * INTERNAL: This module contains the fully generated definition of `ForFieldDecrementAssign` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::ForFieldDecrementAssign` class directly. + * Use the subclass `ForFieldDecrementAssign`, where the following predicates are available. + */ + class ForFieldDecrementAssign extends Synth::TForFieldDecrementAssign, + ForExpressionAssignImpl::ForExpressionAssign + { + override string getAPrimaryQlClass() { result = "ForFieldDecrementAssign" } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/ForFieldIncrementAssign.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/ForFieldIncrementAssign.qll new file mode 100644 index 000000000000..122510d673fa --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/ForFieldIncrementAssign.qll @@ -0,0 +1,25 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `ForFieldIncrementAssign`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.ForExpressionAssignImpl::Impl as ForExpressionAssignImpl + +/** + * INTERNAL: This module contains the fully generated definition of `ForFieldIncrementAssign` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::ForFieldIncrementAssign` class directly. + * Use the subclass `ForFieldIncrementAssign`, where the following predicates are available. + */ + class ForFieldIncrementAssign extends Synth::TForFieldIncrementAssign, + ForExpressionAssignImpl::ForExpressionAssign + { + override string getAPrimaryQlClass() { result = "ForFieldIncrementAssign" } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/ForFieldPostDecrement.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/ForFieldPostDecrement.qll new file mode 100644 index 000000000000..275c71c1920e --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/ForFieldPostDecrement.qll @@ -0,0 +1,23 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `ForFieldPostDecrement`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.ForAssignImpl::Impl as ForAssignImpl + +/** + * INTERNAL: This module contains the fully generated definition of `ForFieldPostDecrement` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::ForFieldPostDecrement` class directly. + * Use the subclass `ForFieldPostDecrement`, where the following predicates are available. + */ + class ForFieldPostDecrement extends Synth::TForFieldPostDecrement, ForAssignImpl::ForAssign { + override string getAPrimaryQlClass() { result = "ForFieldPostDecrement" } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/ForFieldPostIncrement.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/ForFieldPostIncrement.qll new file mode 100644 index 000000000000..1db377fef29c --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/ForFieldPostIncrement.qll @@ -0,0 +1,23 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `ForFieldPostIncrement`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.ForAssignImpl::Impl as ForAssignImpl + +/** + * INTERNAL: This module contains the fully generated definition of `ForFieldPostIncrement` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::ForFieldPostIncrement` class directly. + * Use the subclass `ForFieldPostIncrement`, where the following predicates are available. + */ + class ForFieldPostIncrement extends Synth::TForFieldPostIncrement, ForAssignImpl::ForAssign { + override string getAPrimaryQlClass() { result = "ForFieldPostIncrement" } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/ForFieldPreDecrement.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/ForFieldPreDecrement.qll new file mode 100644 index 000000000000..d61ff2436d9c --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/ForFieldPreDecrement.qll @@ -0,0 +1,23 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `ForFieldPreDecrement`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.ForAssignImpl::Impl as ForAssignImpl + +/** + * INTERNAL: This module contains the fully generated definition of `ForFieldPreDecrement` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::ForFieldPreDecrement` class directly. + * Use the subclass `ForFieldPreDecrement`, where the following predicates are available. + */ + class ForFieldPreDecrement extends Synth::TForFieldPreDecrement, ForAssignImpl::ForAssign { + override string getAPrimaryQlClass() { result = "ForFieldPreDecrement" } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/ForFieldPreIncrement.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/ForFieldPreIncrement.qll new file mode 100644 index 000000000000..8532f0d9afb9 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/ForFieldPreIncrement.qll @@ -0,0 +1,23 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `ForFieldPreIncrement`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.ForAssignImpl::Impl as ForAssignImpl + +/** + * INTERNAL: This module contains the fully generated definition of `ForFieldPreIncrement` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::ForFieldPreIncrement` class directly. + * Use the subclass `ForFieldPreIncrement`, where the following predicates are available. + */ + class ForFieldPreIncrement extends Synth::TForFieldPreIncrement, ForAssignImpl::ForAssign { + override string getAPrimaryQlClass() { result = "ForFieldPreIncrement" } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/ForStatement.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/ForStatement.qll new file mode 100644 index 000000000000..59da0c044e81 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/ForStatement.qll @@ -0,0 +1,86 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `ForStatement`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.Expression +import codeql.xpp.elements.ForAssign +import codeql.xpp.elements.Statement +import codeql.xpp.elements.internal.StatementImpl::Impl as StatementImpl + +/** + * INTERNAL: This module contains the fully generated definition of `ForStatement` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::ForStatement` class directly. + * Use the subclass `ForStatement`, where the following predicates are available. + */ + class ForStatement extends Synth::TForStatement, StatementImpl::Statement { + override string getAPrimaryQlClass() { result = "ForStatement" } + + /** + * Gets the condition of this for statement, if it exists. + */ + Expression getCondition() { + result = + Synth::convertExpressionFromRaw(Synth::convertForStatementToRaw(this) + .(Raw::ForStatement) + .getCondition()) + } + + /** + * Holds if `getCondition()` exists. + */ + final predicate hasCondition() { exists(this.getCondition()) } + + /** + * Gets the initialization of this for statement, if it exists. + */ + ForAssign getInitialization() { + result = + Synth::convertForAssignFromRaw(Synth::convertForStatementToRaw(this) + .(Raw::ForStatement) + .getInitialization()) + } + + /** + * Holds if `getInitialization()` exists. + */ + final predicate hasInitialization() { exists(this.getInitialization()) } + + /** + * Gets the statement of this for statement, if it exists. + */ + Statement getStatement() { + result = + Synth::convertStatementFromRaw(Synth::convertForStatementToRaw(this) + .(Raw::ForStatement) + .getStatement()) + } + + /** + * Holds if `getStatement()` exists. + */ + final predicate hasStatement() { exists(this.getStatement()) } + + /** + * Gets the update of this for statement, if it exists. + */ + ForAssign getUpdate() { + result = + Synth::convertForAssignFromRaw(Synth::convertForStatementToRaw(this) + .(Raw::ForStatement) + .getUpdate()) + } + + /** + * Holds if `getUpdate()` exists. + */ + final predicate hasUpdate() { exists(this.getUpdate()) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/FormControl.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/FormControl.qll new file mode 100644 index 000000000000..55c4234f27fd --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/FormControl.qll @@ -0,0 +1,135 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `FormControl`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.FormControl +import codeql.xpp.elements.internal.FormNestedElementImpl::Impl as FormNestedElementImpl + +private class FormControlAlias = FormControl; + +/** + * INTERNAL: This module contains the fully generated definition of `FormControl` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::FormControl` class directly. + * Use the subclass `FormControl`, where the following predicates are available. + */ + class FormControl extends Synth::TFormControl, FormNestedElementImpl::FormNestedElement { + override string getAPrimaryQlClass() { result = "FormControl" } + + /** + * Holds if this form control auto declaration. + */ + predicate autoDeclaration() { + Synth::convertFormControlToRaw(this).(Raw::FormControl).autoDeclaration() + } + + /** + * Gets the `index`th child control of this form control (0-based). + */ + FormControlAlias getChildControl(int index) { + result = + Synth::convertFormControlFromRaw(Synth::convertFormControlToRaw(this) + .(Raw::FormControl) + .getChildControl(index)) + } + + /** + * Gets any of the child controls of this form control. + */ + final FormControlAlias getAChildControl() { result = this.getChildControl(_) } + + /** + * Gets the number of child controls of this form control. + */ + final int getNumberOfChildControls() { result = count(int i | exists(this.getChildControl(i))) } + + /** + * Gets the control class of this form control, if it exists. + */ + string getControlClass() { + result = Synth::convertFormControlToRaw(this).(Raw::FormControl).getControlClass() + } + + /** + * Holds if `getControlClass()` exists. + */ + final predicate hasControlClass() { exists(this.getControlClass()) } + + /** + * Gets the control type of this form control, if it exists. + */ + string getControlType() { + result = Synth::convertFormControlToRaw(this).(Raw::FormControl).getControlType() + } + + /** + * Holds if `getControlType()` exists. + */ + final predicate hasControlType() { exists(this.getControlType()) } + + /** + * Gets the custom control class of this form control, if it exists. + */ + string getCustomControlClass() { + result = Synth::convertFormControlToRaw(this).(Raw::FormControl).getCustomControlClass() + } + + /** + * Holds if `getCustomControlClass()` exists. + */ + final predicate hasCustomControlClass() { exists(this.getCustomControlClass()) } + + /** + * Gets the element type name of this form control, if it exists. + */ + string getElementTypeName() { + result = Synth::convertFormControlToRaw(this).(Raw::FormControl).getElementTypeName() + } + + /** + * Holds if `getElementTypeName()` exists. + */ + final predicate hasElementTypeName() { exists(this.getElementTypeName()) } + + /** + * Gets the internal control name of this form control, if it exists. + */ + string getInternalControlName() { + result = Synth::convertFormControlToRaw(this).(Raw::FormControl).getInternalControlName() + } + + /** + * Holds if `getInternalControlName()` exists. + */ + final predicate hasInternalControlName() { exists(this.getInternalControlName()) } + + /** + * Holds if this form control is form control extension. + */ + predicate isFormControlExtension() { + Synth::convertFormControlToRaw(this).(Raw::FormControl).isFormControlExtension() + } + + /** + * Gets the parent control of this form control, if it exists. + */ + FormControlAlias getParentControl() { + result = + Synth::convertFormControlFromRaw(Synth::convertFormControlToRaw(this) + .(Raw::FormControl) + .getParentControl()) + } + + /** + * Holds if `getParentControl()` exists. + */ + final predicate hasParentControl() { exists(this.getParentControl()) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/FormDataField.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/FormDataField.qll new file mode 100644 index 000000000000..5a6d21897be0 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/FormDataField.qll @@ -0,0 +1,51 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `FormDataField`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.FormDataSource +import codeql.xpp.elements.internal.FormNestedElementImpl::Impl as FormNestedElementImpl + +/** + * INTERNAL: This module contains the fully generated definition of `FormDataField` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::FormDataField` class directly. + * Use the subclass `FormDataField`, where the following predicates are available. + */ + class FormDataField extends Synth::TFormDataField, FormNestedElementImpl::FormNestedElement { + override string getAPrimaryQlClass() { result = "FormDataField" } + + /** + * Gets the element type name of this form data field, if it exists. + */ + string getElementTypeName() { + result = Synth::convertFormDataFieldToRaw(this).(Raw::FormDataField).getElementTypeName() + } + + /** + * Holds if `getElementTypeName()` exists. + */ + final predicate hasElementTypeName() { exists(this.getElementTypeName()) } + + /** + * Gets the form data source of this form data field, if it exists. + */ + FormDataSource getFormDataSource() { + result = + Synth::convertFormDataSourceFromRaw(Synth::convertFormDataFieldToRaw(this) + .(Raw::FormDataField) + .getFormDataSource()) + } + + /** + * Holds if `getFormDataSource()` exists. + */ + final predicate hasFormDataSource() { exists(this.getFormDataSource()) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/FormDataSource.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/FormDataSource.qll new file mode 100644 index 000000000000..52a6be795bc4 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/FormDataSource.qll @@ -0,0 +1,127 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `FormDataSource`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.FormDataField +import codeql.xpp.elements.internal.FormNestedElementImpl::Impl as FormNestedElementImpl +import codeql.xpp.elements.QueryModelElement + +/** + * INTERNAL: This module contains the fully generated definition of `FormDataSource` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::FormDataSource` class directly. + * Use the subclass `FormDataSource`, where the following predicates are available. + */ + class FormDataSource extends Synth::TFormDataSource, FormNestedElementImpl::FormNestedElement { + override string getAPrimaryQlClass() { result = "FormDataSource" } + + /** + * Gets the `index`th data field of this form data source (0-based). + */ + FormDataField getDataField(int index) { + result = + Synth::convertFormDataFieldFromRaw(Synth::convertFormDataSourceToRaw(this) + .(Raw::FormDataSource) + .getDataField(index)) + } + + /** + * Gets any of the data fields of this form data source. + */ + final FormDataField getADataField() { result = this.getDataField(_) } + + /** + * Gets the number of data fields of this form data source. + */ + final int getNumberOfDataFields() { result = count(int i | exists(this.getDataField(i))) } + + /** + * Gets the element type name of this form data source, if it exists. + */ + string getElementTypeName() { + result = Synth::convertFormDataSourceToRaw(this).(Raw::FormDataSource).getElementTypeName() + } + + /** + * Holds if `getElementTypeName()` exists. + */ + final predicate hasElementTypeName() { exists(this.getElementTypeName()) } + + /** + * Gets the join source of this form data source, if it exists. + */ + string getJoinSource() { + result = Synth::convertFormDataSourceToRaw(this).(Raw::FormDataSource).getJoinSource() + } + + /** + * Holds if `getJoinSource()` exists. + */ + final predicate hasJoinSource() { exists(this.getJoinSource()) } + + /** + * Gets the link type of this form data source, if it exists. + */ + string getLinkType() { + result = Synth::convertFormDataSourceToRaw(this).(Raw::FormDataSource).getLinkType() + } + + /** + * Holds if `getLinkType()` exists. + */ + final predicate hasLinkType() { exists(this.getLinkType()) } + + /** + * Holds if this form data source nested data source. + */ + predicate nestedDataSource() { + Synth::convertFormDataSourceToRaw(this).(Raw::FormDataSource).nestedDataSource() + } + + /** + * Gets the query of this form data source, if it exists. + */ + QueryModelElement getQuery() { + result = + Synth::convertQueryModelElementFromRaw(Synth::convertFormDataSourceToRaw(this) + .(Raw::FormDataSource) + .getQuery()) + } + + /** + * Holds if `getQuery()` exists. + */ + final predicate hasQuery() { exists(this.getQuery()) } + + /** + * Gets the query name of this form data source, if it exists. + */ + string getQueryName() { + result = Synth::convertFormDataSourceToRaw(this).(Raw::FormDataSource).getQueryName() + } + + /** + * Holds if `getQueryName()` exists. + */ + final predicate hasQueryName() { exists(this.getQueryName()) } + + /** + * Gets the table of this form data source, if it exists. + */ + string getTable() { + result = Synth::convertFormDataSourceToRaw(this).(Raw::FormDataSource).getTable() + } + + /** + * Holds if `getTable()` exists. + */ + final predicate hasTable() { exists(this.getTable()) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/FormElementType.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/FormElementType.qll new file mode 100644 index 000000000000..92cc1a2fb543 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/FormElementType.qll @@ -0,0 +1,35 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `FormElementType`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.NamedTypeImpl::Impl as NamedTypeImpl + +/** + * INTERNAL: This module contains the fully generated definition of `FormElementType` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::FormElementType` class directly. + * Use the subclass `FormElementType`, where the following predicates are available. + */ + class FormElementType extends Synth::TFormElementType, NamedTypeImpl::NamedType { + override string getAPrimaryQlClass() { result = "FormElementType" } + + /** + * Gets the form name of this form element type, if it exists. + */ + string getFormName() { + result = Synth::convertFormElementTypeToRaw(this).(Raw::FormElementType).getFormName() + } + + /** + * Holds if `getFormName()` exists. + */ + final predicate hasFormName() { exists(this.getFormName()) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/FormModelElement.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/FormModelElement.qll new file mode 100644 index 000000000000..82b94424280c --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/FormModelElement.qll @@ -0,0 +1,106 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `FormModelElement`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.Class +import codeql.xpp.elements.FormControl +import codeql.xpp.elements.FormDataSource +import codeql.xpp.elements.internal.ModelElementImpl::Impl as ModelElementImpl + +/** + * INTERNAL: This module contains the fully generated definition of `FormModelElement` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::FormModelElement` class directly. + * Use the subclass `FormModelElement`, where the following predicates are available. + */ + class FormModelElement extends Synth::TFormModelElement, ModelElementImpl::ModelElement { + override string getAPrimaryQlClass() { result = "FormModelElement" } + + /** + * Gets the behavior of this form model element, if it exists. + */ + Class getBehavior() { + result = + Synth::convertClassFromRaw(Synth::convertFormModelElementToRaw(this) + .(Raw::FormModelElement) + .getBehavior()) + } + + /** + * Holds if `getBehavior()` exists. + */ + final predicate hasBehavior() { exists(this.getBehavior()) } + + /** + * Gets the `index`th control of this form model element (0-based). + */ + FormControl getControl(int index) { + result = + Synth::convertFormControlFromRaw(Synth::convertFormModelElementToRaw(this) + .(Raw::FormModelElement) + .getControl(index)) + } + + /** + * Gets any of the controls of this form model element. + */ + final FormControl getAControl() { result = this.getControl(_) } + + /** + * Gets the number of controls of this form model element. + */ + final int getNumberOfControls() { result = count(int i | exists(this.getControl(i))) } + + /** + * Gets the `index`th data source of this form model element (0-based). + */ + FormDataSource getDataSource(int index) { + result = + Synth::convertFormDataSourceFromRaw(Synth::convertFormModelElementToRaw(this) + .(Raw::FormModelElement) + .getDataSource(index)) + } + + /** + * Gets any of the data sources of this form model element. + */ + final FormDataSource getADataSource() { result = this.getDataSource(_) } + + /** + * Gets the number of data sources of this form model element. + */ + final int getNumberOfDataSources() { result = count(int i | exists(this.getDataSource(i))) } + + /** + * Gets the element type name of this form model element, if it exists. + */ + string getElementTypeName() { + result = + Synth::convertFormModelElementToRaw(this).(Raw::FormModelElement).getElementTypeName() + } + + /** + * Holds if `getElementTypeName()` exists. + */ + final predicate hasElementTypeName() { exists(this.getElementTypeName()) } + + /** + * Gets the full type name of this form model element, if it exists. + */ + string getFullTypeName() { + result = Synth::convertFormModelElementToRaw(this).(Raw::FormModelElement).getFullTypeName() + } + + /** + * Holds if `getFullTypeName()` exists. + */ + final predicate hasFullTypeName() { exists(this.getFullTypeName()) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/FormNestedElement.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/FormNestedElement.qll new file mode 100644 index 000000000000..f3b557b59d9e --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/FormNestedElement.qll @@ -0,0 +1,37 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `FormNestedElement`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.FormModelElement +import codeql.xpp.elements.internal.ModelElementImpl::Impl as ModelElementImpl + +/** + * INTERNAL: This module contains the fully generated definition of `FormNestedElement` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::FormNestedElement` class directly. + * Use the subclass `FormNestedElement`, where the following predicates are available. + */ + class FormNestedElement extends Synth::TFormNestedElement, ModelElementImpl::ModelElement { + /** + * Gets the form of this form nested element, if it exists. + */ + FormModelElement getForm() { + result = + Synth::convertFormModelElementFromRaw(Synth::convertFormNestedElementToRaw(this) + .(Raw::FormNestedElement) + .getForm()) + } + + /** + * Holds if `getForm()` exists. + */ + final predicate hasForm() { exists(this.getForm()) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/FunctionCall.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/FunctionCall.qll new file mode 100644 index 000000000000..54d5f79124ec --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/FunctionCall.qll @@ -0,0 +1,35 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `FunctionCall`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.GenericEvaluationImpl::Impl as GenericEvaluationImpl + +/** + * INTERNAL: This module contains the fully generated definition of `FunctionCall` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::FunctionCall` class directly. + * Use the subclass `FunctionCall`, where the following predicates are available. + */ + class FunctionCall extends Synth::TFunctionCall, GenericEvaluationImpl::GenericEvaluation { + override string getAPrimaryQlClass() { result = "FunctionCall" } + + /** + * Gets the function name of this function call, if it exists. + */ + string getFunctionName() { + result = Synth::convertFunctionCallToRaw(this).(Raw::FunctionCall).getFunctionName() + } + + /** + * Holds if `getFunctionName()` exists. + */ + final predicate hasFunctionName() { exists(this.getFunctionName()) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/FunctionDeclaration.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/FunctionDeclaration.qll new file mode 100644 index 000000000000..58a381eca5e9 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/FunctionDeclaration.qll @@ -0,0 +1,123 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `FunctionDeclaration`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.LocalDeclaration +import codeql.xpp.elements.internal.LocalDeclarationImpl::Impl as LocalDeclarationImpl +import codeql.xpp.elements.ParameterDeclaration +import codeql.xpp.elements.Statement + +/** + * INTERNAL: This module contains the fully generated definition of `FunctionDeclaration` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::FunctionDeclaration` class directly. + * Use the subclass `FunctionDeclaration`, where the following predicates are available. + */ + class FunctionDeclaration extends Synth::TFunctionDeclaration, + LocalDeclarationImpl::LocalDeclaration + { + override string getAPrimaryQlClass() { result = "FunctionDeclaration" } + + /** + * Gets the `index`th declarations and statement of this function declaration (0-based). + */ + Statement getDeclarationsAndStatement(int index) { + result = + Synth::convertStatementFromRaw(Synth::convertFunctionDeclarationToRaw(this) + .(Raw::FunctionDeclaration) + .getDeclarationsAndStatement(index)) + } + + /** + * Gets any of the declarations and statements of this function declaration. + */ + final Statement getADeclarationsAndStatement() { result = this.getDeclarationsAndStatement(_) } + + /** + * Gets the number of declarations and statements of this function declaration. + */ + final int getNumberOfDeclarationsAndStatements() { + result = count(int i | exists(this.getDeclarationsAndStatement(i))) + } + + /** + * Gets the element type name of this function declaration, if it exists. + */ + string getElementTypeName() { + result = + Synth::convertFunctionDeclarationToRaw(this).(Raw::FunctionDeclaration).getElementTypeName() + } + + /** + * Holds if `getElementTypeName()` exists. + */ + final predicate hasElementTypeName() { exists(this.getElementTypeName()) } + + /** + * Gets the `index`th local of this function declaration (0-based). + */ + LocalDeclaration getLocal(int index) { + result = + Synth::convertLocalDeclarationFromRaw(Synth::convertFunctionDeclarationToRaw(this) + .(Raw::FunctionDeclaration) + .getLocal(index)) + } + + /** + * Gets any of the locals of this function declaration. + */ + final LocalDeclaration getALocal() { result = this.getLocal(_) } + + /** + * Gets the number of locals of this function declaration. + */ + final int getNumberOfLocals() { result = count(int i | exists(this.getLocal(i))) } + + /** + * Gets the `index`th parameter of this function declaration (0-based). + */ + ParameterDeclaration getParameter(int index) { + result = + Synth::convertParameterDeclarationFromRaw(Synth::convertFunctionDeclarationToRaw(this) + .(Raw::FunctionDeclaration) + .getParameter(index)) + } + + /** + * Gets any of the parameters of this function declaration. + */ + final ParameterDeclaration getAParameter() { result = this.getParameter(_) } + + /** + * Gets the number of parameters of this function declaration. + */ + final int getNumberOfParameters() { result = count(int i | exists(this.getParameter(i))) } + + /** + * Gets the `index`th statement of this function declaration (0-based). + */ + Statement getStatement(int index) { + result = + Synth::convertStatementFromRaw(Synth::convertFunctionDeclarationToRaw(this) + .(Raw::FunctionDeclaration) + .getStatement(index)) + } + + /** + * Gets any of the statements of this function declaration. + */ + final Statement getAStatement() { result = this.getStatement(_) } + + /** + * Gets the number of statements of this function declaration. + */ + final int getNumberOfStatements() { result = count(int i | exists(this.getStatement(i))) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/GenericEvaluation.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/GenericEvaluation.qll new file mode 100644 index 000000000000..23512c81ca17 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/GenericEvaluation.qll @@ -0,0 +1,44 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `GenericEvaluation`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.EvaluationImpl::Impl as EvaluationImpl +import codeql.xpp.elements.XppType + +/** + * INTERNAL: This module contains the fully generated definition of `GenericEvaluation` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::GenericEvaluation` class directly. + * Use the subclass `GenericEvaluation`, where the following predicates are available. + */ + class GenericEvaluation extends Synth::TGenericEvaluation, EvaluationImpl::Evaluation { + /** + * Gets the `index`th type argument list of this generic evaluation (0-based). + */ + XppType getTypeArgumentList(int index) { + result = + Synth::convertXppTypeFromRaw(Synth::convertGenericEvaluationToRaw(this) + .(Raw::GenericEvaluation) + .getTypeArgumentList(index)) + } + + /** + * Gets any of the type argument lists of this generic evaluation. + */ + final XppType getATypeArgumentList() { result = this.getTypeArgumentList(_) } + + /** + * Gets the number of type argument lists of this generic evaluation. + */ + final int getNumberOfTypeArgumentLists() { + result = count(int i | exists(this.getTypeArgumentList(i))) + } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/GenericXppType.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/GenericXppType.qll new file mode 100644 index 000000000000..6ebb6f7dec6b --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/GenericXppType.qll @@ -0,0 +1,44 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `GenericXppType`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.XppType +import codeql.xpp.elements.internal.XppTypeImpl::Impl as XppTypeImpl + +/** + * INTERNAL: This module contains the fully generated definition of `GenericXppType` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::GenericXppType` class directly. + * Use the subclass `GenericXppType`, where the following predicates are available. + */ + class GenericXppType extends Synth::TGenericXppType, XppTypeImpl::XppType { + /** + * Gets the `index`th type argument list of this generic xpp type (0-based). + */ + XppType getTypeArgumentList(int index) { + result = + Synth::convertXppTypeFromRaw(Synth::convertGenericXppTypeToRaw(this) + .(Raw::GenericXppType) + .getTypeArgumentList(index)) + } + + /** + * Gets any of the type argument lists of this generic xpp type. + */ + final XppType getATypeArgumentList() { result = this.getTypeArgumentList(_) } + + /** + * Gets the number of type argument lists of this generic xpp type. + */ + final int getNumberOfTypeArgumentLists() { + result = count(int i | exists(this.getTypeArgumentList(i))) + } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/GlobalOrderElement.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/GlobalOrderElement.qll new file mode 100644 index 000000000000..ff1c933eb3ef --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/GlobalOrderElement.qll @@ -0,0 +1,48 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `GlobalOrderElement`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.OrderElementImpl::Impl as OrderElementImpl + +/** + * INTERNAL: This module contains the fully generated definition of `GlobalOrderElement` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::GlobalOrderElement` class directly. + * Use the subclass `GlobalOrderElement`, where the following predicates are available. + */ + class GlobalOrderElement extends Synth::TGlobalOrderElement, OrderElementImpl::OrderElement { + override string getAPrimaryQlClass() { result = "GlobalOrderElement" } + + /** + * Gets the extension name of this global order element, if it exists. + */ + string getExtensionName() { + result = + Synth::convertGlobalOrderElementToRaw(this).(Raw::GlobalOrderElement).getExtensionName() + } + + /** + * Holds if `getExtensionName()` exists. + */ + final predicate hasExtensionName() { exists(this.getExtensionName()) } + + /** + * Gets the table of this global order element, if it exists. + */ + string getTable() { + result = Synth::convertGlobalOrderElementToRaw(this).(Raw::GlobalOrderElement).getTable() + } + + /** + * Holds if `getTable()` exists. + */ + final predicate hasTable() { exists(this.getTable()) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/GreaterThanExpression.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/GreaterThanExpression.qll new file mode 100644 index 000000000000..fe8a4e75f9e4 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/GreaterThanExpression.qll @@ -0,0 +1,25 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `GreaterThanExpression`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.RelationalExpressionImpl::Impl as RelationalExpressionImpl + +/** + * INTERNAL: This module contains the fully generated definition of `GreaterThanExpression` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::GreaterThanExpression` class directly. + * Use the subclass `GreaterThanExpression`, where the following predicates are available. + */ + class GreaterThanExpression extends Synth::TGreaterThanExpression, + RelationalExpressionImpl::RelationalExpression + { + override string getAPrimaryQlClass() { result = "GreaterThanExpression" } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/GreaterThanOrEqualExpression.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/GreaterThanOrEqualExpression.qll new file mode 100644 index 000000000000..6dab2e694d19 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/GreaterThanOrEqualExpression.qll @@ -0,0 +1,25 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `GreaterThanOrEqualExpression`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.RelationalExpressionImpl::Impl as RelationalExpressionImpl + +/** + * INTERNAL: This module contains the fully generated definition of `GreaterThanOrEqualExpression` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::GreaterThanOrEqualExpression` class directly. + * Use the subclass `GreaterThanOrEqualExpression`, where the following predicates are available. + */ + class GreaterThanOrEqualExpression extends Synth::TGreaterThanOrEqualExpression, + RelationalExpressionImpl::RelationalExpression + { + override string getAPrimaryQlClass() { result = "GreaterThanOrEqualExpression" } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/GuidAttributeLiteral.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/GuidAttributeLiteral.qll new file mode 100644 index 000000000000..2e082549f4f2 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/GuidAttributeLiteral.qll @@ -0,0 +1,25 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `GuidAttributeLiteral`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.DefaultTypeAttributeLiteralImpl::Impl as DefaultTypeAttributeLiteralImpl + +/** + * INTERNAL: This module contains the fully generated definition of `GuidAttributeLiteral` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::GuidAttributeLiteral` class directly. + * Use the subclass `GuidAttributeLiteral`, where the following predicates are available. + */ + class GuidAttributeLiteral extends Synth::TGuidAttributeLiteral, + DefaultTypeAttributeLiteralImpl::DefaultTypeAttributeLiteral + { + override string getAPrimaryQlClass() { result = "GuidAttributeLiteral" } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/GuidType.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/GuidType.qll new file mode 100644 index 000000000000..e2e190680c67 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/GuidType.qll @@ -0,0 +1,23 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `GuidType`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.XppTypeImpl::Impl as XppTypeImpl + +/** + * INTERNAL: This module contains the fully generated definition of `GuidType` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::GuidType` class directly. + * Use the subclass `GuidType`, where the following predicates are available. + */ + class GuidType extends Synth::TGuidType, XppTypeImpl::XppType { + override string getAPrimaryQlClass() { result = "GuidType" } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/IfStatement.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/IfStatement.qll new file mode 100644 index 000000000000..a063c567d8db --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/IfStatement.qll @@ -0,0 +1,55 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `IfStatement`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.Expression +import codeql.xpp.elements.Statement +import codeql.xpp.elements.internal.StatementImpl::Impl as StatementImpl + +/** + * INTERNAL: This module contains the fully generated definition of `IfStatement` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::IfStatement` class directly. + * Use the subclass `IfStatement`, where the following predicates are available. + */ + class IfStatement extends Synth::TIfStatement, StatementImpl::Statement { + override string getAPrimaryQlClass() { result = "IfStatement" } + + /** + * Gets the condition of this if statement, if it exists. + */ + Expression getCondition() { + result = + Synth::convertExpressionFromRaw(Synth::convertIfStatementToRaw(this) + .(Raw::IfStatement) + .getCondition()) + } + + /** + * Holds if `getCondition()` exists. + */ + final predicate hasCondition() { exists(this.getCondition()) } + + /** + * Gets the consequent of this if statement, if it exists. + */ + Statement getConsequent() { + result = + Synth::convertStatementFromRaw(Synth::convertIfStatementToRaw(this) + .(Raw::IfStatement) + .getConsequent()) + } + + /** + * Holds if `getConsequent()` exists. + */ + final predicate hasConsequent() { exists(this.getConsequent()) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/IfThenElseStatement.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/IfThenElseStatement.qll new file mode 100644 index 000000000000..7ac27ebb46f1 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/IfThenElseStatement.qll @@ -0,0 +1,70 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `IfThenElseStatement`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.Expression +import codeql.xpp.elements.Statement +import codeql.xpp.elements.internal.StatementImpl::Impl as StatementImpl + +/** + * INTERNAL: This module contains the fully generated definition of `IfThenElseStatement` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::IfThenElseStatement` class directly. + * Use the subclass `IfThenElseStatement`, where the following predicates are available. + */ + class IfThenElseStatement extends Synth::TIfThenElseStatement, StatementImpl::Statement { + override string getAPrimaryQlClass() { result = "IfThenElseStatement" } + + /** + * Gets the antecedent of this if then else statement, if it exists. + */ + Statement getAntecedent() { + result = + Synth::convertStatementFromRaw(Synth::convertIfThenElseStatementToRaw(this) + .(Raw::IfThenElseStatement) + .getAntecedent()) + } + + /** + * Holds if `getAntecedent()` exists. + */ + final predicate hasAntecedent() { exists(this.getAntecedent()) } + + /** + * Gets the condition of this if then else statement, if it exists. + */ + Expression getCondition() { + result = + Synth::convertExpressionFromRaw(Synth::convertIfThenElseStatementToRaw(this) + .(Raw::IfThenElseStatement) + .getCondition()) + } + + /** + * Holds if `getCondition()` exists. + */ + final predicate hasCondition() { exists(this.getCondition()) } + + /** + * Gets the consequent of this if then else statement, if it exists. + */ + Statement getConsequent() { + result = + Synth::convertStatementFromRaw(Synth::convertIfThenElseStatementToRaw(this) + .(Raw::IfThenElseStatement) + .getConsequent()) + } + + /** + * Holds if `getConsequent()` exists. + */ + final predicate hasConsequent() { exists(this.getConsequent()) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/ImplicitSelection.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/ImplicitSelection.qll new file mode 100644 index 000000000000..bd0fc53e1368 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/ImplicitSelection.qll @@ -0,0 +1,23 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `ImplicitSelection`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.SelectionImpl::Impl as SelectionImpl + +/** + * INTERNAL: This module contains the fully generated definition of `ImplicitSelection` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::ImplicitSelection` class directly. + * Use the subclass `ImplicitSelection`, where the following predicates are available. + */ + class ImplicitSelection extends Synth::TImplicitSelection, SelectionImpl::Selection { + override string getAPrimaryQlClass() { result = "ImplicitSelection" } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/InExpression.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/InExpression.qll new file mode 100644 index 000000000000..d34097ccec9c --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/InExpression.qll @@ -0,0 +1,23 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `InExpression`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.BinaryExpressionImpl::Impl as BinaryExpressionImpl + +/** + * INTERNAL: This module contains the fully generated definition of `InExpression` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::InExpression` class directly. + * Use the subclass `InExpression`, where the following predicates are available. + */ + class InExpression extends Synth::TInExpression, BinaryExpressionImpl::BinaryExpression { + override string getAPrimaryQlClass() { result = "InExpression" } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/InsertFieldSpecification.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/InsertFieldSpecification.qll new file mode 100644 index 000000000000..bb339b0ee2c2 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/InsertFieldSpecification.qll @@ -0,0 +1,75 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `InsertFieldSpecification`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.AstImpl::Impl as AstImpl + +/** + * INTERNAL: This module contains the fully generated definition of `InsertFieldSpecification` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::InsertFieldSpecification` class directly. + * Use the subclass `InsertFieldSpecification`, where the following predicates are available. + */ + class InsertFieldSpecification extends Synth::TInsertFieldSpecification, AstImpl::Ast { + override string getAPrimaryQlClass() { result = "InsertFieldSpecification" } + + /** + * Gets the array index of this insert field specification, if it exists. + */ + int getArrayIndex() { + result = + Synth::convertInsertFieldSpecificationToRaw(this) + .(Raw::InsertFieldSpecification) + .getArrayIndex() + } + + /** + * Holds if `getArrayIndex()` exists. + */ + final predicate hasArrayIndex() { exists(this.getArrayIndex()) } + + /** + * Gets the extension name of this insert field specification, if it exists. + */ + string getExtensionName() { + result = + Synth::convertInsertFieldSpecificationToRaw(this) + .(Raw::InsertFieldSpecification) + .getExtensionName() + } + + /** + * Holds if `getExtensionName()` exists. + */ + final predicate hasExtensionName() { exists(this.getExtensionName()) } + + /** + * Holds if this insert field specification is extension. + */ + predicate isExtension() { + Synth::convertInsertFieldSpecificationToRaw(this) + .(Raw::InsertFieldSpecification) + .isExtension() + } + + /** + * Gets the name of this insert field specification, if it exists. + */ + string getName() { + result = + Synth::convertInsertFieldSpecificationToRaw(this).(Raw::InsertFieldSpecification).getName() + } + + /** + * Holds if `getName()` exists. + */ + final predicate hasName() { exists(this.getName()) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/InsertStatement.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/InsertStatement.qll new file mode 100644 index 000000000000..1ef5915cc0a5 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/InsertStatement.qll @@ -0,0 +1,88 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `InsertStatement`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.CrossCompany +import codeql.xpp.elements.InsertFieldSpecification +import codeql.xpp.elements.Query +import codeql.xpp.elements.internal.StatementImpl::Impl as StatementImpl + +/** + * INTERNAL: This module contains the fully generated definition of `InsertStatement` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::InsertStatement` class directly. + * Use the subclass `InsertStatement`, where the following predicates are available. + */ + class InsertStatement extends Synth::TInsertStatement, StatementImpl::Statement { + override string getAPrimaryQlClass() { result = "InsertStatement" } + + /** + * Gets the cross company of this insert statement, if it exists. + */ + CrossCompany getCrossCompany() { + result = + Synth::convertCrossCompanyFromRaw(Synth::convertInsertStatementToRaw(this) + .(Raw::InsertStatement) + .getCrossCompany()) + } + + /** + * Holds if `getCrossCompany()` exists. + */ + final predicate hasCrossCompany() { exists(this.getCrossCompany()) } + + /** + * Gets the `index`th field of this insert statement (0-based). + */ + InsertFieldSpecification getField(int index) { + result = + Synth::convertInsertFieldSpecificationFromRaw(Synth::convertInsertStatementToRaw(this) + .(Raw::InsertStatement) + .getField(index)) + } + + /** + * Gets any of the fields of this insert statement. + */ + final InsertFieldSpecification getAField() { result = this.getField(_) } + + /** + * Gets the number of fields of this insert statement. + */ + final int getNumberOfFields() { result = count(int i | exists(this.getField(i))) } + + /** + * Gets the query of this insert statement, if it exists. + */ + Query getQuery() { + result = + Synth::convertQueryFromRaw(Synth::convertInsertStatementToRaw(this) + .(Raw::InsertStatement) + .getQuery()) + } + + /** + * Holds if `getQuery()` exists. + */ + final predicate hasQuery() { exists(this.getQuery()) } + + /** + * Gets the table of this insert statement, if it exists. + */ + string getTable() { + result = Synth::convertInsertStatementToRaw(this).(Raw::InsertStatement).getTable() + } + + /** + * Holds if `getTable()` exists. + */ + final predicate hasTable() { exists(this.getTable()) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/InstanceName.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/InstanceName.qll new file mode 100644 index 000000000000..59408089b60f --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/InstanceName.qll @@ -0,0 +1,21 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `InstanceName`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.AstImpl::Impl as AstImpl + +/** + * INTERNAL: This module contains the fully generated definition of `InstanceName` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::InstanceName` class directly. + * Use the subclass `InstanceName`, where the following predicates are available. + */ + class InstanceName extends Synth::TInstanceName, AstImpl::Ast { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/Int64AttributeLiteral.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/Int64AttributeLiteral.qll new file mode 100644 index 000000000000..9935cffa959e --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/Int64AttributeLiteral.qll @@ -0,0 +1,25 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `Int64AttributeLiteral`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.DefaultTypeAttributeLiteralImpl::Impl as DefaultTypeAttributeLiteralImpl + +/** + * INTERNAL: This module contains the fully generated definition of `Int64AttributeLiteral` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::Int64AttributeLiteral` class directly. + * Use the subclass `Int64AttributeLiteral`, where the following predicates are available. + */ + class Int64AttributeLiteral extends Synth::TInt64AttributeLiteral, + DefaultTypeAttributeLiteralImpl::DefaultTypeAttributeLiteral + { + override string getAPrimaryQlClass() { result = "Int64AttributeLiteral" } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/Int64LiteralExpression.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/Int64LiteralExpression.qll new file mode 100644 index 000000000000..f3622a0555d2 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/Int64LiteralExpression.qll @@ -0,0 +1,25 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `Int64LiteralExpression`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.DefaultTypeLiteralExpressionImpl::Impl as DefaultTypeLiteralExpressionImpl + +/** + * INTERNAL: This module contains the fully generated definition of `Int64LiteralExpression` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::Int64LiteralExpression` class directly. + * Use the subclass `Int64LiteralExpression`, where the following predicates are available. + */ + class Int64LiteralExpression extends Synth::TInt64LiteralExpression, + DefaultTypeLiteralExpressionImpl::DefaultTypeLiteralExpression + { + override string getAPrimaryQlClass() { result = "Int64LiteralExpression" } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/Int64Type.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/Int64Type.qll new file mode 100644 index 000000000000..d78d2d374018 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/Int64Type.qll @@ -0,0 +1,23 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `Int64Type`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.XppTypeImpl::Impl as XppTypeImpl + +/** + * INTERNAL: This module contains the fully generated definition of `Int64Type` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::Int64Type` class directly. + * Use the subclass `Int64Type`, where the following predicates are available. + */ + class Int64Type extends Synth::TInt64Type, XppTypeImpl::XppType { + override string getAPrimaryQlClass() { result = "Int64Type" } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/IntAttributeLiteral.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/IntAttributeLiteral.qll new file mode 100644 index 000000000000..67dd415e5fa5 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/IntAttributeLiteral.qll @@ -0,0 +1,25 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `IntAttributeLiteral`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.DefaultTypeAttributeLiteralImpl::Impl as DefaultTypeAttributeLiteralImpl + +/** + * INTERNAL: This module contains the fully generated definition of `IntAttributeLiteral` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::IntAttributeLiteral` class directly. + * Use the subclass `IntAttributeLiteral`, where the following predicates are available. + */ + class IntAttributeLiteral extends Synth::TIntAttributeLiteral, + DefaultTypeAttributeLiteralImpl::DefaultTypeAttributeLiteral + { + override string getAPrimaryQlClass() { result = "IntAttributeLiteral" } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/IntLiteralExpression.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/IntLiteralExpression.qll new file mode 100644 index 000000000000..ab46614cc79d --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/IntLiteralExpression.qll @@ -0,0 +1,25 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `IntLiteralExpression`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.DefaultTypeLiteralExpressionImpl::Impl as DefaultTypeLiteralExpressionImpl + +/** + * INTERNAL: This module contains the fully generated definition of `IntLiteralExpression` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::IntLiteralExpression` class directly. + * Use the subclass `IntLiteralExpression`, where the following predicates are available. + */ + class IntLiteralExpression extends Synth::TIntLiteralExpression, + DefaultTypeLiteralExpressionImpl::DefaultTypeLiteralExpression + { + override string getAPrimaryQlClass() { result = "IntLiteralExpression" } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/IntType.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/IntType.qll new file mode 100644 index 000000000000..69fa5afa1082 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/IntType.qll @@ -0,0 +1,23 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `IntType`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.XppTypeImpl::Impl as XppTypeImpl + +/** + * INTERNAL: This module contains the fully generated definition of `IntType` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::IntType` class directly. + * Use the subclass `IntType`, where the following predicates are available. + */ + class IntType extends Synth::TIntType, XppTypeImpl::XppType { + override string getAPrimaryQlClass() { result = "IntType" } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/IntegerDivideExpression.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/IntegerDivideExpression.qll new file mode 100644 index 000000000000..dcbab6a47b81 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/IntegerDivideExpression.qll @@ -0,0 +1,25 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `IntegerDivideExpression`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.BinaryExpressionImpl::Impl as BinaryExpressionImpl + +/** + * INTERNAL: This module contains the fully generated definition of `IntegerDivideExpression` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::IntegerDivideExpression` class directly. + * Use the subclass `IntegerDivideExpression`, where the following predicates are available. + */ + class IntegerDivideExpression extends Synth::TIntegerDivideExpression, + BinaryExpressionImpl::BinaryExpression + { + override string getAPrimaryQlClass() { result = "IntegerDivideExpression" } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/Interface.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/Interface.qll new file mode 100644 index 000000000000..3c4d1d3f3455 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/Interface.qll @@ -0,0 +1,23 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `Interface`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.ClassOrInterfaceImpl::Impl as ClassOrInterfaceImpl + +/** + * INTERNAL: This module contains the fully generated definition of `Interface` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::Interface` class directly. + * Use the subclass `Interface`, where the following predicates are available. + */ + class Interface extends Synth::TInterface, ClassOrInterfaceImpl::ClassOrInterface { + override string getAPrimaryQlClass() { result = "Interface" } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/Intrinsic.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/Intrinsic.qll new file mode 100644 index 000000000000..c712a1108fa3 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/Intrinsic.qll @@ -0,0 +1,63 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `Intrinsic`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.ExpressionImpl::Impl as ExpressionImpl + +/** + * INTERNAL: This module contains the fully generated definition of `Intrinsic` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::Intrinsic` class directly. + * Use the subclass `Intrinsic`, where the following predicates are available. + */ + class Intrinsic extends Synth::TIntrinsic, ExpressionImpl::Expression { + override string getAPrimaryQlClass() { result = "Intrinsic" } + + /** + * Gets the arg1 of this intrinsic, if it exists. + */ + string getArg1() { result = Synth::convertIntrinsicToRaw(this).(Raw::Intrinsic).getArg1() } + + /** + * Holds if `getArg1()` exists. + */ + final predicate hasArg1() { exists(this.getArg1()) } + + /** + * Gets the arg2 of this intrinsic, if it exists. + */ + string getArg2() { result = Synth::convertIntrinsicToRaw(this).(Raw::Intrinsic).getArg2() } + + /** + * Holds if `getArg2()` exists. + */ + final predicate hasArg2() { exists(this.getArg2()) } + + /** + * Gets the arg3 of this intrinsic, if it exists. + */ + string getArg3() { result = Synth::convertIntrinsicToRaw(this).(Raw::Intrinsic).getArg3() } + + /** + * Holds if `getArg3()` exists. + */ + final predicate hasArg3() { exists(this.getArg3()) } + + /** + * Gets the name of this intrinsic, if it exists. + */ + string getName() { result = Synth::convertIntrinsicToRaw(this).(Raw::Intrinsic).getName() } + + /** + * Holds if `getName()` exists. + */ + final predicate hasName() { exists(this.getName()) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/IntrinsicAttributeLiteral.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/IntrinsicAttributeLiteral.qll new file mode 100644 index 000000000000..80e53b15606a --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/IntrinsicAttributeLiteral.qll @@ -0,0 +1,85 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `IntrinsicAttributeLiteral`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.AttributeLiteralImpl::Impl as AttributeLiteralImpl + +/** + * INTERNAL: This module contains the fully generated definition of `IntrinsicAttributeLiteral` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::IntrinsicAttributeLiteral` class directly. + * Use the subclass `IntrinsicAttributeLiteral`, where the following predicates are available. + */ + class IntrinsicAttributeLiteral extends Synth::TIntrinsicAttributeLiteral, + AttributeLiteralImpl::AttributeLiteral + { + override string getAPrimaryQlClass() { result = "IntrinsicAttributeLiteral" } + + /** + * Gets the arg1 of this intrinsic attribute literal, if it exists. + */ + string getArg1() { + result = + Synth::convertIntrinsicAttributeLiteralToRaw(this) + .(Raw::IntrinsicAttributeLiteral) + .getArg1() + } + + /** + * Holds if `getArg1()` exists. + */ + final predicate hasArg1() { exists(this.getArg1()) } + + /** + * Gets the arg2 of this intrinsic attribute literal, if it exists. + */ + string getArg2() { + result = + Synth::convertIntrinsicAttributeLiteralToRaw(this) + .(Raw::IntrinsicAttributeLiteral) + .getArg2() + } + + /** + * Holds if `getArg2()` exists. + */ + final predicate hasArg2() { exists(this.getArg2()) } + + /** + * Gets the arg3 of this intrinsic attribute literal, if it exists. + */ + string getArg3() { + result = + Synth::convertIntrinsicAttributeLiteralToRaw(this) + .(Raw::IntrinsicAttributeLiteral) + .getArg3() + } + + /** + * Holds if `getArg3()` exists. + */ + final predicate hasArg3() { exists(this.getArg3()) } + + /** + * Gets the function name of this intrinsic attribute literal, if it exists. + */ + string getFunctionName() { + result = + Synth::convertIntrinsicAttributeLiteralToRaw(this) + .(Raw::IntrinsicAttributeLiteral) + .getFunctionName() + } + + /** + * Holds if `getFunctionName()` exists. + */ + final predicate hasFunctionName() { exists(this.getFunctionName()) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/IsAsExpression.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/IsAsExpression.qll new file mode 100644 index 000000000000..50f992faa5aa --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/IsAsExpression.qll @@ -0,0 +1,49 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `IsAsExpression`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.Expression +import codeql.xpp.elements.internal.ExpressionImpl::Impl as ExpressionImpl + +/** + * INTERNAL: This module contains the fully generated definition of `IsAsExpression` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::IsAsExpression` class directly. + * Use the subclass `IsAsExpression`, where the following predicates are available. + */ + class IsAsExpression extends Synth::TIsAsExpression, ExpressionImpl::Expression { + /** + * Gets the expression of this is as expression, if it exists. + */ + Expression getExpression() { + result = + Synth::convertExpressionFromRaw(Synth::convertIsAsExpressionToRaw(this) + .(Raw::IsAsExpression) + .getExpression()) + } + + /** + * Holds if `getExpression()` exists. + */ + final predicate hasExpression() { exists(this.getExpression()) } + + /** + * Gets the type name of this is as expression, if it exists. + */ + string getTypeName() { + result = Synth::convertIsAsExpressionToRaw(this).(Raw::IsAsExpression).getTypeName() + } + + /** + * Holds if `getTypeName()` exists. + */ + final predicate hasTypeName() { exists(this.getTypeName()) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/IsClrExpression.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/IsClrExpression.qll new file mode 100644 index 000000000000..80535e548ad0 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/IsClrExpression.qll @@ -0,0 +1,23 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `IsClrExpression`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.IsAsExpressionImpl::Impl as IsAsExpressionImpl + +/** + * INTERNAL: This module contains the fully generated definition of `IsClrExpression` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::IsClrExpression` class directly. + * Use the subclass `IsClrExpression`, where the following predicates are available. + */ + class IsClrExpression extends Synth::TIsClrExpression, IsAsExpressionImpl::IsAsExpression { + override string getAPrimaryQlClass() { result = "IsClrExpression" } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/IsExpression.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/IsExpression.qll new file mode 100644 index 000000000000..c2dc9939a5be --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/IsExpression.qll @@ -0,0 +1,23 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `IsExpression`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.IsAsExpressionImpl::Impl as IsAsExpressionImpl + +/** + * INTERNAL: This module contains the fully generated definition of `IsExpression` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::IsExpression` class directly. + * Use the subclass `IsExpression`, where the following predicates are available. + */ + class IsExpression extends Synth::TIsExpression, IsAsExpressionImpl::IsAsExpression { + override string getAPrimaryQlClass() { result = "IsExpression" } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/JoinSpecification.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/JoinSpecification.qll new file mode 100644 index 000000000000..5221a6bd8dfd --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/JoinSpecification.qll @@ -0,0 +1,51 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `JoinSpecification`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.AstImpl::Impl as AstImpl +import codeql.xpp.elements.Query + +/** + * INTERNAL: This module contains the fully generated definition of `JoinSpecification` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::JoinSpecification` class directly. + * Use the subclass `JoinSpecification`, where the following predicates are available. + */ + class JoinSpecification extends Synth::TJoinSpecification, AstImpl::Ast { + override string getAPrimaryQlClass() { result = "JoinSpecification" } + + /** + * Gets the kind of this join specification, if it exists. + */ + string getKind() { + result = Synth::convertJoinSpecificationToRaw(this).(Raw::JoinSpecification).getKind() + } + + /** + * Holds if `getKind()` exists. + */ + final predicate hasKind() { exists(this.getKind()) } + + /** + * Gets the query of this join specification, if it exists. + */ + Query getQuery() { + result = + Synth::convertQueryFromRaw(Synth::convertJoinSpecificationToRaw(this) + .(Raw::JoinSpecification) + .getQuery()) + } + + /** + * Holds if `getQuery()` exists. + */ + final predicate hasQuery() { exists(this.getQuery()) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/LessThanExpression.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/LessThanExpression.qll new file mode 100644 index 000000000000..23502b0aed0e --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/LessThanExpression.qll @@ -0,0 +1,25 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `LessThanExpression`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.RelationalExpressionImpl::Impl as RelationalExpressionImpl + +/** + * INTERNAL: This module contains the fully generated definition of `LessThanExpression` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::LessThanExpression` class directly. + * Use the subclass `LessThanExpression`, where the following predicates are available. + */ + class LessThanExpression extends Synth::TLessThanExpression, + RelationalExpressionImpl::RelationalExpression + { + override string getAPrimaryQlClass() { result = "LessThanExpression" } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/LessThanOrEqualExpression.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/LessThanOrEqualExpression.qll new file mode 100644 index 000000000000..497cf0b4b7ca --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/LessThanOrEqualExpression.qll @@ -0,0 +1,25 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `LessThanOrEqualExpression`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.RelationalExpressionImpl::Impl as RelationalExpressionImpl + +/** + * INTERNAL: This module contains the fully generated definition of `LessThanOrEqualExpression` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::LessThanOrEqualExpression` class directly. + * Use the subclass `LessThanOrEqualExpression`, where the following predicates are available. + */ + class LessThanOrEqualExpression extends Synth::TLessThanOrEqualExpression, + RelationalExpressionImpl::RelationalExpression + { + override string getAPrimaryQlClass() { result = "LessThanOrEqualExpression" } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/LikeExpression.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/LikeExpression.qll new file mode 100644 index 000000000000..d40fc0b8817b --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/LikeExpression.qll @@ -0,0 +1,25 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `LikeExpression`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.RelationalExpressionImpl::Impl as RelationalExpressionImpl + +/** + * INTERNAL: This module contains the fully generated definition of `LikeExpression` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::LikeExpression` class directly. + * Use the subclass `LikeExpression`, where the following predicates are available. + */ + class LikeExpression extends Synth::TLikeExpression, + RelationalExpressionImpl::RelationalExpression + { + override string getAPrimaryQlClass() { result = "LikeExpression" } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/LiteralExpression.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/LiteralExpression.qll new file mode 100644 index 000000000000..3c8b44f438a6 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/LiteralExpression.qll @@ -0,0 +1,21 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `LiteralExpression`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.ExpressionImpl::Impl as ExpressionImpl + +/** + * INTERNAL: This module contains the fully generated definition of `LiteralExpression` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::LiteralExpression` class directly. + * Use the subclass `LiteralExpression`, where the following predicates are available. + */ + class LiteralExpression extends Synth::TLiteralExpression, ExpressionImpl::Expression { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/LocalDeclaration.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/LocalDeclaration.qll new file mode 100644 index 000000000000..cdd4d27dc4db --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/LocalDeclaration.qll @@ -0,0 +1,21 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `LocalDeclaration`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.DeclarationImpl::Impl as DeclarationImpl + +/** + * INTERNAL: This module contains the fully generated definition of `LocalDeclaration` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::LocalDeclaration` class directly. + * Use the subclass `LocalDeclaration`, where the following predicates are available. + */ + class LocalDeclaration extends Synth::TLocalDeclaration, DeclarationImpl::Declaration { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/LocalDeclarationsStatement.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/LocalDeclarationsStatement.qll new file mode 100644 index 000000000000..e545fe9d7977 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/LocalDeclarationsStatement.qll @@ -0,0 +1,46 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `LocalDeclarationsStatement`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.LocalDeclaration +import codeql.xpp.elements.internal.StatementImpl::Impl as StatementImpl + +/** + * INTERNAL: This module contains the fully generated definition of `LocalDeclarationsStatement` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::LocalDeclarationsStatement` class directly. + * Use the subclass `LocalDeclarationsStatement`, where the following predicates are available. + */ + class LocalDeclarationsStatement extends Synth::TLocalDeclarationsStatement, + StatementImpl::Statement + { + override string getAPrimaryQlClass() { result = "LocalDeclarationsStatement" } + + /** + * Gets the `index`th declaration of this local declarations statement (0-based). + */ + LocalDeclaration getDeclaration(int index) { + result = + Synth::convertLocalDeclarationFromRaw(Synth::convertLocalDeclarationsStatementToRaw(this) + .(Raw::LocalDeclarationsStatement) + .getDeclaration(index)) + } + + /** + * Gets any of the declarations of this local declarations statement. + */ + final LocalDeclaration getADeclaration() { result = this.getDeclaration(_) } + + /** + * Gets the number of declarations of this local declarations statement. + */ + final int getNumberOfDeclarations() { result = count(int i | exists(this.getDeclaration(i))) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/Locatable.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/Locatable.qll new file mode 100644 index 000000000000..f8d3eca65e60 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/Locatable.qll @@ -0,0 +1,37 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `Locatable`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.ElementImpl::Impl as ElementImpl +import codeql.xpp.elements.Location + +/** + * INTERNAL: This module contains the fully generated definition of `Locatable` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::Locatable` class directly. + * Use the subclass `Locatable`, where the following predicates are available. + */ + class Locatable extends Synth::TLocatable, ElementImpl::Element { + /** + * Gets the location associated with this element in the code, if it exists. + */ + Location getLocation() { + result = + Synth::convertLocationFromRaw(Synth::convertLocatableToRaw(this) + .(Raw::Locatable) + .getLocation()) + } + + /** + * Holds if `getLocation()` exists. + */ + final predicate hasLocation() { exists(this.getLocation()) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/Location.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/Location.qll new file mode 100644 index 000000000000..a91112490196 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/Location.qll @@ -0,0 +1,54 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `Location`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.ElementImpl::Impl as ElementImpl +import codeql.xpp.elements.File + +/** + * INTERNAL: This module contains the fully generated definition of `Location` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::Location` class directly. + * Use the subclass `Location`, where the following predicates are available. + */ + class Location extends Synth::TLocation, ElementImpl::Element { + override string getAPrimaryQlClass() { result = "Location" } + + /** + * Gets the file of this location. + */ + File getFile() { + result = + Synth::convertFileFromRaw(Synth::convertLocationToRaw(this).(Raw::Location).getFile()) + } + + /** + * Gets the start line of this location. + */ + int getStartLine() { result = Synth::convertLocationToRaw(this).(Raw::Location).getStartLine() } + + /** + * Gets the start column of this location. + */ + int getStartColumn() { + result = Synth::convertLocationToRaw(this).(Raw::Location).getStartColumn() + } + + /** + * Gets the end line of this location. + */ + int getEndLine() { result = Synth::convertLocationToRaw(this).(Raw::Location).getEndLine() } + + /** + * Gets the end column of this location. + */ + int getEndColumn() { result = Synth::convertLocationToRaw(this).(Raw::Location).getEndColumn() } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/MaxAggregateSelection.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/MaxAggregateSelection.qll new file mode 100644 index 000000000000..00adbc79f16c --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/MaxAggregateSelection.qll @@ -0,0 +1,25 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `MaxAggregateSelection`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.AggregateSelectionImpl::Impl as AggregateSelectionImpl + +/** + * INTERNAL: This module contains the fully generated definition of `MaxAggregateSelection` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::MaxAggregateSelection` class directly. + * Use the subclass `MaxAggregateSelection`, where the following predicates are available. + */ + class MaxAggregateSelection extends Synth::TMaxAggregateSelection, + AggregateSelectionImpl::AggregateSelection + { + override string getAPrimaryQlClass() { result = "MaxAggregateSelection" } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/Method.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/Method.qll new file mode 100644 index 000000000000..41bcc15462c1 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/Method.qll @@ -0,0 +1,214 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `Method`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.LocalDeclaration +import codeql.xpp.elements.internal.MethodOrDelegateImpl::Impl as MethodOrDelegateImpl +import codeql.xpp.elements.Statement + +/** + * INTERNAL: This module contains the fully generated definition of `Method` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::Method` class directly. + * Use the subclass `Method`, where the following predicates are available. + */ + class Method extends Synth::TMethod, MethodOrDelegateImpl::MethodOrDelegate { + override string getAPrimaryQlClass() { result = "Method" } + + /** + * Gets the `index`th declarations and statement of this method (0-based). + */ + Statement getDeclarationsAndStatement(int index) { + result = + Synth::convertStatementFromRaw(Synth::convertMethodToRaw(this) + .(Raw::Method) + .getDeclarationsAndStatement(index)) + } + + /** + * Gets any of the declarations and statements of this method. + */ + final Statement getADeclarationsAndStatement() { result = this.getDeclarationsAndStatement(_) } + + /** + * Gets the number of declarations and statements of this method. + */ + final int getNumberOfDeclarationsAndStatements() { + result = count(int i | exists(this.getDeclarationsAndStatement(i))) + } + + /** + * Holds if this method has local functions. + */ + predicate hasLocalFunctions() { + Synth::convertMethodToRaw(this).(Raw::Method).hasLocalFunctions() + } + + /** + * Holds if this method is abstract. + */ + predicate isAbstract() { Synth::convertMethodToRaw(this).(Raw::Method).isAbstract() } + + /** + * Holds if this method is client. + */ + predicate isClient() { Synth::convertMethodToRaw(this).(Raw::Method).isClient() } + + /** + * Holds if this method is constructor. + */ + predicate isConstructor() { Synth::convertMethodToRaw(this).(Raw::Method).isConstructor() } + + /** + * Holds if this method is display. + */ + predicate isDisplay() { Synth::convertMethodToRaw(this).(Raw::Method).isDisplay() } + + /** + * Holds if this method is edit. + */ + predicate isEdit() { Synth::convertMethodToRaw(this).(Raw::Method).isEdit() } + + /** + * Holds if this method is explicit non hookable. + */ + predicate isExplicitNonHookable() { + Synth::convertMethodToRaw(this).(Raw::Method).isExplicitNonHookable() + } + + /** + * Holds if this method is explicit non wrappable. + */ + predicate isExplicitNonWrappable() { + Synth::convertMethodToRaw(this).(Raw::Method).isExplicitNonWrappable() + } + + /** + * Holds if this method is extended method. + */ + predicate isExtendedMethod() { + Synth::convertMethodToRaw(this).(Raw::Method).isExtendedMethod() + } + + /** + * Holds if this method is final. + */ + predicate isFinal() { Synth::convertMethodToRaw(this).(Raw::Method).isFinal() } + + /** + * Holds if this method is hookable. + */ + predicate isHookable() { Synth::convertMethodToRaw(this).(Raw::Method).isHookable() } + + /** + * Holds if this method is hookable on chain of command. + */ + predicate isHookableOnChainOfCommand() { + Synth::convertMethodToRaw(this).(Raw::Method).isHookableOnChainOfCommand() + } + + /** + * Holds if this method is internal. + */ + predicate isInternal() { Synth::convertMethodToRaw(this).(Raw::Method).isInternal() } + + /** + * Holds if this method is private. + */ + predicate isPrivate() { Synth::convertMethodToRaw(this).(Raw::Method).isPrivate() } + + /** + * Holds if this method is protected. + */ + predicate isProtected() { Synth::convertMethodToRaw(this).(Raw::Method).isProtected() } + + /** + * Holds if this method is public. + */ + predicate isPublic() { Synth::convertMethodToRaw(this).(Raw::Method).isPublic() } + + /** + * Holds if this method is replaceable. + */ + predicate isReplaceable() { Synth::convertMethodToRaw(this).(Raw::Method).isReplaceable() } + + /** + * Holds if this method is server. + */ + predicate isServer() { Synth::convertMethodToRaw(this).(Raw::Method).isServer() } + + /** + * Holds if this method is static. + */ + predicate isStatic() { Synth::convertMethodToRaw(this).(Raw::Method).isStatic() } + + /** + * Holds if this method is type initializer. + */ + predicate isTypeInitializer() { + Synth::convertMethodToRaw(this).(Raw::Method).isTypeInitializer() + } + + /** + * Holds if this method is wrappable. + */ + predicate isWrappable() { Synth::convertMethodToRaw(this).(Raw::Method).isWrappable() } + + /** + * Gets the `index`th local of this method (0-based). + */ + LocalDeclaration getLocal(int index) { + result = + Synth::convertLocalDeclarationFromRaw(Synth::convertMethodToRaw(this) + .(Raw::Method) + .getLocal(index)) + } + + /** + * Gets any of the locals of this method. + */ + final LocalDeclaration getALocal() { result = this.getLocal(_) } + + /** + * Gets the number of locals of this method. + */ + final int getNumberOfLocals() { result = count(int i | exists(this.getLocal(i))) } + + /** + * Gets the modifiers of this method, if it exists. + */ + string getModifiers() { result = Synth::convertMethodToRaw(this).(Raw::Method).getModifiers() } + + /** + * Holds if `getModifiers()` exists. + */ + final predicate hasModifiers() { exists(this.getModifiers()) } + + /** + * Gets the `index`th statement of this method (0-based). + */ + Statement getStatement(int index) { + result = + Synth::convertStatementFromRaw(Synth::convertMethodToRaw(this) + .(Raw::Method) + .getStatement(index)) + } + + /** + * Gets any of the statements of this method. + */ + final Statement getAStatement() { result = this.getStatement(_) } + + /** + * Gets the number of statements of this method. + */ + final int getNumberOfStatements() { result = count(int i | exists(this.getStatement(i))) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/MethodOrDelegate.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/MethodOrDelegate.qll new file mode 100644 index 000000000000..11ea7da4b6c4 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/MethodOrDelegate.qll @@ -0,0 +1,128 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `MethodOrDelegate`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.AttributeList +import codeql.xpp.elements.internal.CompilationUnitImpl::Impl as CompilationUnitImpl +import codeql.xpp.elements.Modifier +import codeql.xpp.elements.ParameterDeclaration +import codeql.xpp.elements.XppType + +/** + * INTERNAL: This module contains the fully generated definition of `MethodOrDelegate` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::MethodOrDelegate` class directly. + * Use the subclass `MethodOrDelegate`, where the following predicates are available. + */ + class MethodOrDelegate extends Synth::TMethodOrDelegate, CompilationUnitImpl::CompilationUnit { + /** + * Gets the attributes of this method or delegate, if it exists. + */ + AttributeList getAttributes() { + result = + Synth::convertAttributeListFromRaw(Synth::convertMethodOrDelegateToRaw(this) + .(Raw::MethodOrDelegate) + .getAttributes()) + } + + /** + * Holds if `getAttributes()` exists. + */ + final predicate hasAttributes() { exists(this.getAttributes()) } + + /** + * Gets the `index`th modifier list of this method or delegate (0-based). + */ + Modifier getModifierList(int index) { + result = + Synth::convertModifierFromRaw(Synth::convertMethodOrDelegateToRaw(this) + .(Raw::MethodOrDelegate) + .getModifierList(index)) + } + + /** + * Gets any of the modifier lists of this method or delegate. + */ + final Modifier getAModifierList() { result = this.getModifierList(_) } + + /** + * Gets the number of modifier lists of this method or delegate. + */ + final int getNumberOfModifierLists() { result = count(int i | exists(this.getModifierList(i))) } + + /** + * Gets the `index`th parameter of this method or delegate (0-based). + */ + ParameterDeclaration getParameter(int index) { + result = + Synth::convertParameterDeclarationFromRaw(Synth::convertMethodOrDelegateToRaw(this) + .(Raw::MethodOrDelegate) + .getParameter(index)) + } + + /** + * Gets any of the parameters of this method or delegate. + */ + final ParameterDeclaration getAParameter() { result = this.getParameter(_) } + + /** + * Gets the number of parameters of this method or delegate. + */ + final int getNumberOfParameters() { result = count(int i | exists(this.getParameter(i))) } + + /** + * Gets the path contribution of this method or delegate, if it exists. + */ + string getPathContribution() { + result = + Synth::convertMethodOrDelegateToRaw(this).(Raw::MethodOrDelegate).getPathContribution() + } + + /** + * Holds if `getPathContribution()` exists. + */ + final predicate hasPathContribution() { exists(this.getPathContribution()) } + + /** + * Gets the type of this method or delegate, if it exists. + */ + XppType getType() { + result = + Synth::convertXppTypeFromRaw(Synth::convertMethodOrDelegateToRaw(this) + .(Raw::MethodOrDelegate) + .getType()) + } + + /** + * Holds if `getType()` exists. + */ + final predicate hasType() { exists(this.getType()) } + + /** + * Gets the `index`th type parameter of this method or delegate (0-based). + */ + string getTypeParameter(int index) { + result = + Synth::convertMethodOrDelegateToRaw(this).(Raw::MethodOrDelegate).getTypeParameter(index) + } + + /** + * Gets any of the type parameters of this method or delegate. + */ + final string getATypeParameter() { result = this.getTypeParameter(_) } + + /** + * Gets the number of type parameters of this method or delegate. + */ + final int getNumberOfTypeParameters() { + result = count(int i | exists(this.getTypeParameter(i))) + } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/MinAggregateSelection.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/MinAggregateSelection.qll new file mode 100644 index 000000000000..c29476b49abc --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/MinAggregateSelection.qll @@ -0,0 +1,25 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `MinAggregateSelection`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.AggregateSelectionImpl::Impl as AggregateSelectionImpl + +/** + * INTERNAL: This module contains the fully generated definition of `MinAggregateSelection` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::MinAggregateSelection` class directly. + * Use the subclass `MinAggregateSelection`, where the following predicates are available. + */ + class MinAggregateSelection extends Synth::TMinAggregateSelection, + AggregateSelectionImpl::AggregateSelection + { + override string getAPrimaryQlClass() { result = "MinAggregateSelection" } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/ModExpression.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/ModExpression.qll new file mode 100644 index 000000000000..91730ef61fbb --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/ModExpression.qll @@ -0,0 +1,23 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `ModExpression`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.BinaryExpressionImpl::Impl as BinaryExpressionImpl + +/** + * INTERNAL: This module contains the fully generated definition of `ModExpression` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::ModExpression` class directly. + * Use the subclass `ModExpression`, where the following predicates are available. + */ + class ModExpression extends Synth::TModExpression, BinaryExpressionImpl::BinaryExpression { + override string getAPrimaryQlClass() { result = "ModExpression" } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/ModelElement.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/ModelElement.qll new file mode 100644 index 000000000000..dd66282b204b --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/ModelElement.qll @@ -0,0 +1,281 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `ModelElement`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.ClassAccessModifier +import codeql.xpp.elements.ClassOrInterface +import codeql.xpp.elements.internal.CompilationUnitImpl::Impl as CompilationUnitImpl +import codeql.xpp.elements.MethodOrDelegate +import codeql.xpp.elements.ModelElementUsingEntry +import codeql.xpp.elements.XppType + +/** + * INTERNAL: This module contains the fully generated definition of `ModelElement` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::ModelElement` class directly. + * Use the subclass `ModelElement`, where the following predicates are available. + */ + class ModelElement extends Synth::TModelElement, CompilationUnitImpl::CompilationUnit { + /** + * Gets the `index`th base method of this model element (0-based). + */ + MethodOrDelegate getBaseMethod(int index) { + result = + Synth::convertMethodOrDelegateFromRaw(Synth::convertModelElementToRaw(this) + .(Raw::ModelElement) + .getBaseMethod(index)) + } + + /** + * Gets any of the base methods of this model element. + */ + final MethodOrDelegate getABaseMethod() { result = this.getBaseMethod(_) } + + /** + * Gets the number of base methods of this model element. + */ + final int getNumberOfBaseMethods() { result = count(int i | exists(this.getBaseMethod(i))) } + + /** + * Gets the `index`th extend generic parameter of this model element (0-based). + */ + XppType getExtendGenericParameter(int index) { + result = + Synth::convertXppTypeFromRaw(Synth::convertModelElementToRaw(this) + .(Raw::ModelElement) + .getExtendGenericParameter(index)) + } + + /** + * Gets any of the extend generic parameters of this model element. + */ + final XppType getAnExtendGenericParameter() { result = this.getExtendGenericParameter(_) } + + /** + * Gets the number of extend generic parameters of this model element. + */ + final int getNumberOfExtendGenericParameters() { + result = count(int i | exists(this.getExtendGenericParameter(i))) + } + + /** + * Gets the full name of this model element, if it exists. + */ + string getFullName() { + result = Synth::convertModelElementToRaw(this).(Raw::ModelElement).getFullName() + } + + /** + * Holds if `getFullName()` exists. + */ + final predicate hasFullName() { exists(this.getFullName()) } + + /** + * Gets the full name no default namespace of this model element, if it exists. + */ + string getFullNameNoDefaultNamespace() { + result = + Synth::convertModelElementToRaw(this).(Raw::ModelElement).getFullNameNoDefaultNamespace() + } + + /** + * Holds if `getFullNameNoDefaultNamespace()` exists. + */ + final predicate hasFullNameNoDefaultNamespace() { exists(this.getFullNameNoDefaultNamespace()) } + + /** + * Holds if this model element is internal. + */ + predicate isInternal() { + Synth::convertModelElementToRaw(this).(Raw::ModelElement).isInternal() + } + + /** + * Holds if this model element is kernel. + */ + predicate isKernel() { Synth::convertModelElementToRaw(this).(Raw::ModelElement).isKernel() } + + /** + * Holds if this model element is obsolete. + */ + predicate isObsolete() { + Synth::convertModelElementToRaw(this).(Raw::ModelElement).isObsolete() + } + + /** + * Holds if this model element is private. + */ + predicate isPrivate() { Synth::convertModelElementToRaw(this).(Raw::ModelElement).isPrivate() } + + /** + * Holds if this model element is public. + */ + predicate isPublic() { Synth::convertModelElementToRaw(this).(Raw::ModelElement).isPublic() } + + /** + * Gets the `index`th method of this model element (0-based). + */ + MethodOrDelegate getMethod(int index) { + result = + Synth::convertMethodOrDelegateFromRaw(Synth::convertModelElementToRaw(this) + .(Raw::ModelElement) + .getMethod(index)) + } + + /** + * Gets any of the methods of this model element. + */ + final MethodOrDelegate getAMethod() { result = this.getMethod(_) } + + /** + * Gets the number of methods of this model element. + */ + final int getNumberOfMethods() { result = count(int i | exists(this.getMethod(i))) } + + /** + * Gets the model of this model element, if it exists. + */ + int getModelId() { + result = Synth::convertModelElementToRaw(this).(Raw::ModelElement).getModelId() + } + + /** + * Holds if `getModelId()` exists. + */ + final predicate hasModelId() { exists(this.getModelId()) } + + /** + * Gets the `index`th modifier list of this model element (0-based). + */ + ClassAccessModifier getModifierList(int index) { + result = + Synth::convertClassAccessModifierFromRaw(Synth::convertModelElementToRaw(this) + .(Raw::ModelElement) + .getModifierList(index)) + } + + /** + * Gets any of the modifier lists of this model element. + */ + final ClassAccessModifier getAModifierList() { result = this.getModifierList(_) } + + /** + * Gets the number of modifier lists of this model element. + */ + final int getNumberOfModifierLists() { result = count(int i | exists(this.getModifierList(i))) } + + /** + * Gets the modifiers of this model element, if it exists. + */ + string getModifiers() { + result = Synth::convertModelElementToRaw(this).(Raw::ModelElement).getModifiers() + } + + /** + * Holds if `getModifiers()` exists. + */ + final predicate hasModifiers() { exists(this.getModifiers()) } + + /** + * Gets the namespace of this model element, if it exists. + */ + string getNamespace() { + result = Synth::convertModelElementToRaw(this).(Raw::ModelElement).getNamespace() + } + + /** + * Holds if `getNamespace()` exists. + */ + final predicate hasNamespace() { exists(this.getNamespace()) } + + /** + * Gets the `index`th nested class of this model element (0-based). + */ + ClassOrInterface getNestedClass(int index) { + result = + Synth::convertClassOrInterfaceFromRaw(Synth::convertModelElementToRaw(this) + .(Raw::ModelElement) + .getNestedClass(index)) + } + + /** + * Gets any of the nested classes of this model element. + */ + final ClassOrInterface getANestedClass() { result = this.getNestedClass(_) } + + /** + * Gets the number of nested classes of this model element. + */ + final int getNumberOfNestedClasses() { result = count(int i | exists(this.getNestedClass(i))) } + + /** + * Gets the path contribution of this model element, if it exists. + */ + string getPathContribution() { + result = Synth::convertModelElementToRaw(this).(Raw::ModelElement).getPathContribution() + } + + /** + * Holds if `getPathContribution()` exists. + */ + final predicate hasPathContribution() { exists(this.getPathContribution()) } + + /** + * Gets the `index`th type parameter of this model element (0-based). + */ + string getTypeParameter(int index) { + result = Synth::convertModelElementToRaw(this).(Raw::ModelElement).getTypeParameter(index) + } + + /** + * Gets any of the type parameters of this model element. + */ + final string getATypeParameter() { result = this.getTypeParameter(_) } + + /** + * Gets the number of type parameters of this model element. + */ + final int getNumberOfTypeParameters() { + result = count(int i | exists(this.getTypeParameter(i))) + } + + /** + * Gets the `index`th using of this model element (0-based). + */ + ModelElementUsingEntry getUsing(int index) { + result = + Synth::convertModelElementUsingEntryFromRaw(Synth::convertModelElementToRaw(this) + .(Raw::ModelElement) + .getUsing(index)) + } + + /** + * Gets any of the usings of this model element. + */ + final ModelElementUsingEntry getAUsing() { result = this.getUsing(_) } + + /** + * Gets the number of usings of this model element. + */ + final int getNumberOfUsings() { result = count(int i | exists(this.getUsing(i))) } + + /** + * Gets the visibility of this model element, if it exists. + */ + string getVisibility() { + result = Synth::convertModelElementToRaw(this).(Raw::ModelElement).getVisibility() + } + + /** + * Holds if `getVisibility()` exists. + */ + final predicate hasVisibility() { exists(this.getVisibility()) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/ModelElementUsingEntry.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/ModelElementUsingEntry.qll new file mode 100644 index 000000000000..bdcd7453b64b --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/ModelElementUsingEntry.qll @@ -0,0 +1,49 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `ModelElementUsingEntry`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.XppTupleImpl::Impl as XppTupleImpl + +/** + * INTERNAL: This module contains the fully generated definition of `ModelElementUsingEntry` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::ModelElementUsingEntry` class directly. + * Use the subclass `ModelElementUsingEntry`, where the following predicates are available. + */ + class ModelElementUsingEntry extends Synth::TModelElementUsingEntry, XppTupleImpl::XppTuple { + override string getAPrimaryQlClass() { result = "ModelElementUsingEntry" } + + /** + * Gets the item2 of this model element using entry, if it exists. + */ + string getItem2() { + result = + Synth::convertModelElementUsingEntryToRaw(this).(Raw::ModelElementUsingEntry).getItem2() + } + + /** + * Holds if `getItem2()` exists. + */ + final predicate hasItem2() { exists(this.getItem2()) } + + /** + * Gets the item3 of this model element using entry, if it exists. + */ + string getItem3() { + result = + Synth::convertModelElementUsingEntryToRaw(this).(Raw::ModelElementUsingEntry).getItem3() + } + + /** + * Holds if `getItem3()` exists. + */ + final predicate hasItem3() { exists(this.getItem3()) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/Modifier.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/Modifier.qll new file mode 100644 index 000000000000..aa20b4898f6d --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/Modifier.qll @@ -0,0 +1,35 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `Modifier`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.AstImpl::Impl as AstImpl + +/** + * INTERNAL: This module contains the fully generated definition of `Modifier` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::Modifier` class directly. + * Use the subclass `Modifier`, where the following predicates are available. + */ + class Modifier extends Synth::TModifier, AstImpl::Ast { + override string getAPrimaryQlClass() { result = "Modifier" } + + /** + * Gets the modifiers of this modifier, if it exists. + */ + string getModifiers() { + result = Synth::convertModifierToRaw(this).(Raw::Modifier).getModifiers() + } + + /** + * Holds if `getModifiers()` exists. + */ + final predicate hasModifiers() { exists(this.getModifiers()) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/MoveCursorStatement.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/MoveCursorStatement.qll new file mode 100644 index 000000000000..21c4c7809492 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/MoveCursorStatement.qll @@ -0,0 +1,51 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `MoveCursorStatement`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.Selection +import codeql.xpp.elements.internal.StatementImpl::Impl as StatementImpl + +/** + * INTERNAL: This module contains the fully generated definition of `MoveCursorStatement` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::MoveCursorStatement` class directly. + * Use the subclass `MoveCursorStatement`, where the following predicates are available. + */ + class MoveCursorStatement extends Synth::TMoveCursorStatement, StatementImpl::Statement { + override string getAPrimaryQlClass() { result = "MoveCursorStatement" } + + /** + * Gets the selection of this move cursor statement, if it exists. + */ + Selection getSelection() { + result = + Synth::convertSelectionFromRaw(Synth::convertMoveCursorStatementToRaw(this) + .(Raw::MoveCursorStatement) + .getSelection()) + } + + /** + * Holds if `getSelection()` exists. + */ + final predicate hasSelection() { exists(this.getSelection()) } + + /** + * Gets the table of this move cursor statement, if it exists. + */ + string getTable() { + result = Synth::convertMoveCursorStatementToRaw(this).(Raw::MoveCursorStatement).getTable() + } + + /** + * Holds if `getTable()` exists. + */ + final predicate hasTable() { exists(this.getTable()) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/MultiplyExpression.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/MultiplyExpression.qll new file mode 100644 index 000000000000..1b7358d73f5b --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/MultiplyExpression.qll @@ -0,0 +1,25 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `MultiplyExpression`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.BinaryExpressionImpl::Impl as BinaryExpressionImpl + +/** + * INTERNAL: This module contains the fully generated definition of `MultiplyExpression` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::MultiplyExpression` class directly. + * Use the subclass `MultiplyExpression`, where the following predicates are available. + */ + class MultiplyExpression extends Synth::TMultiplyExpression, + BinaryExpressionImpl::BinaryExpression + { + override string getAPrimaryQlClass() { result = "MultiplyExpression" } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/NamedFieldReference.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/NamedFieldReference.qll new file mode 100644 index 000000000000..0fc541553f8c --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/NamedFieldReference.qll @@ -0,0 +1,51 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `NamedFieldReference`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.TableFieldReferenceImpl::Impl as TableFieldReferenceImpl + +/** + * INTERNAL: This module contains the fully generated definition of `NamedFieldReference` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::NamedFieldReference` class directly. + * Use the subclass `NamedFieldReference`, where the following predicates are available. + */ + class NamedFieldReference extends Synth::TNamedFieldReference, + TableFieldReferenceImpl::TableFieldReference + { + override string getAPrimaryQlClass() { result = "NamedFieldReference" } + + /** + * Gets the extension name of this named field reference, if it exists. + */ + string getExtensionName() { + result = + Synth::convertNamedFieldReferenceToRaw(this).(Raw::NamedFieldReference).getExtensionName() + } + + /** + * Holds if `getExtensionName()` exists. + */ + final predicate hasExtensionName() { exists(this.getExtensionName()) } + + /** + * Gets the field name of this named field reference, if it exists. + */ + string getFieldName() { + result = + Synth::convertNamedFieldReferenceToRaw(this).(Raw::NamedFieldReference).getFieldName() + } + + /** + * Holds if `getFieldName()` exists. + */ + final predicate hasFieldName() { exists(this.getFieldName()) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/NamedType.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/NamedType.qll new file mode 100644 index 000000000000..b38914df6f0c --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/NamedType.qll @@ -0,0 +1,31 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `NamedType`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.GenericXppTypeImpl::Impl as GenericXppTypeImpl + +/** + * INTERNAL: This module contains the fully generated definition of `NamedType` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::NamedType` class directly. + * Use the subclass `NamedType`, where the following predicates are available. + */ + class NamedType extends Synth::TNamedType, GenericXppTypeImpl::GenericXppType { + /** + * Gets the name of this named type, if it exists. + */ + string getName() { result = Synth::convertNamedTypeToRaw(this).(Raw::NamedType).getName() } + + /** + * Holds if `getName()` exists. + */ + final predicate hasName() { exists(this.getName()) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/NamedTypeInternal.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/NamedTypeInternal.qll new file mode 100644 index 000000000000..67131f8d2f50 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/NamedTypeInternal.qll @@ -0,0 +1,23 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `NamedTypeInternal`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.NamedTypeImpl::Impl as NamedTypeImpl + +/** + * INTERNAL: This module contains the fully generated definition of `NamedTypeInternal` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::NamedTypeInternal` class directly. + * Use the subclass `NamedTypeInternal`, where the following predicates are available. + */ + class NamedTypeInternal extends Synth::TNamedTypeInternal, NamedTypeImpl::NamedType { + override string getAPrimaryQlClass() { result = "NamedTypeInternal" } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/NewCall.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/NewCall.qll new file mode 100644 index 000000000000..c3f5c4af3158 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/NewCall.qll @@ -0,0 +1,37 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `NewCall`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.EvaluationImpl::Impl as EvaluationImpl +import codeql.xpp.elements.XppType + +/** + * INTERNAL: This module contains the fully generated definition of `NewCall` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::NewCall` class directly. + * Use the subclass `NewCall`, where the following predicates are available. + */ + class NewCall extends Synth::TNewCall, EvaluationImpl::Evaluation { + override string getAPrimaryQlClass() { result = "NewCall" } + + /** + * Gets the type of this new call, if it exists. + */ + XppType getType() { + result = + Synth::convertXppTypeFromRaw(Synth::convertNewCallToRaw(this).(Raw::NewCall).getType()) + } + + /** + * Holds if `getType()` exists. + */ + final predicate hasType() { exists(this.getType()) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/NewClrArrayExpression.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/NewClrArrayExpression.qll new file mode 100644 index 000000000000..b22ccdce83ba --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/NewClrArrayExpression.qll @@ -0,0 +1,102 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `NewClrArrayExpression`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.Expression +import codeql.xpp.elements.internal.ExpressionImpl::Impl as ExpressionImpl +import codeql.xpp.elements.XppType + +/** + * INTERNAL: This module contains the fully generated definition of `NewClrArrayExpression` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::NewClrArrayExpression` class directly. + * Use the subclass `NewClrArrayExpression`, where the following predicates are available. + */ + class NewClrArrayExpression extends Synth::TNewClrArrayExpression, ExpressionImpl::Expression { + override string getAPrimaryQlClass() { result = "NewClrArrayExpression" } + + /** + * Gets the full name of this new clr array expression, if it exists. + */ + string getFullName() { + result = + Synth::convertNewClrArrayExpressionToRaw(this).(Raw::NewClrArrayExpression).getFullName() + } + + /** + * Holds if `getFullName()` exists. + */ + final predicate hasFullName() { exists(this.getFullName()) } + + /** + * Gets the `index`th rectangular dimension of this new clr array expression (0-based). + */ + int getRectangularDimension(int index) { + result = + Synth::convertNewClrArrayExpressionToRaw(this) + .(Raw::NewClrArrayExpression) + .getRectangularDimension(index) + } + + /** + * Gets any of the rectangular dimensions of this new clr array expression. + */ + final int getARectangularDimension() { result = this.getRectangularDimension(_) } + + /** + * Gets the number of rectangular dimensions of this new clr array expression. + */ + final int getNumberOfRectangularDimensions() { + result = count(int i | exists(this.getRectangularDimension(i))) + } + + /** + * Gets the `index`th size of this new clr array expression (0-based). + */ + Expression getSize(int index) { + result = + Synth::convertExpressionFromRaw(Synth::convertNewClrArrayExpressionToRaw(this) + .(Raw::NewClrArrayExpression) + .getSize(index)) + } + + /** + * Gets any of the sizes of this new clr array expression. + */ + final Expression getASize() { result = this.getSize(_) } + + /** + * Gets the number of sizes of this new clr array expression. + */ + final int getNumberOfSizes() { result = count(int i | exists(this.getSize(i))) } + + /** + * Gets the `index`th type argument list of this new clr array expression (0-based). + */ + XppType getTypeArgumentList(int index) { + result = + Synth::convertXppTypeFromRaw(Synth::convertNewClrArrayExpressionToRaw(this) + .(Raw::NewClrArrayExpression) + .getTypeArgumentList(index)) + } + + /** + * Gets any of the type argument lists of this new clr array expression. + */ + final XppType getATypeArgumentList() { result = this.getTypeArgumentList(_) } + + /** + * Gets the number of type argument lists of this new clr array expression. + */ + final int getNumberOfTypeArgumentLists() { + result = count(int i | exists(this.getTypeArgumentList(i))) + } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/NewClrCall.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/NewClrCall.qll new file mode 100644 index 000000000000..382b6373a97f --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/NewClrCall.qll @@ -0,0 +1,35 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `NewClrCall`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.GenericEvaluationImpl::Impl as GenericEvaluationImpl + +/** + * INTERNAL: This module contains the fully generated definition of `NewClrCall` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::NewClrCall` class directly. + * Use the subclass `NewClrCall`, where the following predicates are available. + */ + class NewClrCall extends Synth::TNewClrCall, GenericEvaluationImpl::GenericEvaluation { + override string getAPrimaryQlClass() { result = "NewClrCall" } + + /** + * Gets the clr class name of this new clr call, if it exists. + */ + string getClrClassName() { + result = Synth::convertNewClrCallToRaw(this).(Raw::NewClrCall).getClrClassName() + } + + /** + * Holds if `getClrClassName()` exists. + */ + final predicate hasClrClassName() { exists(this.getClrClassName()) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/NextExpression.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/NextExpression.qll new file mode 100644 index 000000000000..c7530328e25c --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/NextExpression.qll @@ -0,0 +1,35 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `NextExpression`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.EvaluationImpl::Impl as EvaluationImpl + +/** + * INTERNAL: This module contains the fully generated definition of `NextExpression` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::NextExpression` class directly. + * Use the subclass `NextExpression`, where the following predicates are available. + */ + class NextExpression extends Synth::TNextExpression, EvaluationImpl::Evaluation { + override string getAPrimaryQlClass() { result = "NextExpression" } + + /** + * Gets the name of this next expression, if it exists. + */ + string getName() { + result = Synth::convertNextExpressionToRaw(this).(Raw::NextExpression).getName() + } + + /** + * Holds if `getName()` exists. + */ + final predicate hasName() { exists(this.getName()) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/NotEqualExpression.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/NotEqualExpression.qll new file mode 100644 index 000000000000..f4df461d7959 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/NotEqualExpression.qll @@ -0,0 +1,25 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `NotEqualExpression`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.RelationalExpressionImpl::Impl as RelationalExpressionImpl + +/** + * INTERNAL: This module contains the fully generated definition of `NotEqualExpression` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::NotEqualExpression` class directly. + * Use the subclass `NotEqualExpression`, where the following predicates are available. + */ + class NotEqualExpression extends Synth::TNotEqualExpression, + RelationalExpressionImpl::RelationalExpression + { + override string getAPrimaryQlClass() { result = "NotEqualExpression" } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/NotExpression.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/NotExpression.qll new file mode 100644 index 000000000000..2a3b73eca40d --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/NotExpression.qll @@ -0,0 +1,23 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `NotExpression`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.UnaryExpressionImpl::Impl as UnaryExpressionImpl + +/** + * INTERNAL: This module contains the fully generated definition of `NotExpression` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::NotExpression` class directly. + * Use the subclass `NotExpression`, where the following predicates are available. + */ + class NotExpression extends Synth::TNotExpression, UnaryExpressionImpl::UnaryExpression { + override string getAPrimaryQlClass() { result = "NotExpression" } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/NullLiteralExpression.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/NullLiteralExpression.qll new file mode 100644 index 000000000000..00d84e71096c --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/NullLiteralExpression.qll @@ -0,0 +1,25 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `NullLiteralExpression`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.LiteralExpressionImpl::Impl as LiteralExpressionImpl + +/** + * INTERNAL: This module contains the fully generated definition of `NullLiteralExpression` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::NullLiteralExpression` class directly. + * Use the subclass `NullLiteralExpression`, where the following predicates are available. + */ + class NullLiteralExpression extends Synth::TNullLiteralExpression, + LiteralExpressionImpl::LiteralExpression + { + override string getAPrimaryQlClass() { result = "NullLiteralExpression" } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/NumberedFieldReference.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/NumberedFieldReference.qll new file mode 100644 index 000000000000..d36de18735fc --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/NumberedFieldReference.qll @@ -0,0 +1,41 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `NumberedFieldReference`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.Expression +import codeql.xpp.elements.internal.TableFieldReferenceImpl::Impl as TableFieldReferenceImpl + +/** + * INTERNAL: This module contains the fully generated definition of `NumberedFieldReference` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::NumberedFieldReference` class directly. + * Use the subclass `NumberedFieldReference`, where the following predicates are available. + */ + class NumberedFieldReference extends Synth::TNumberedFieldReference, + TableFieldReferenceImpl::TableFieldReference + { + override string getAPrimaryQlClass() { result = "NumberedFieldReference" } + + /** + * Gets the field number of this numbered field reference, if it exists. + */ + Expression getFieldNumber() { + result = + Synth::convertExpressionFromRaw(Synth::convertNumberedFieldReferenceToRaw(this) + .(Raw::NumberedFieldReference) + .getFieldNumber()) + } + + /** + * Holds if `getFieldNumber()` exists. + */ + final predicate hasFieldNumber() { exists(this.getFieldNumber()) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/OrExpression.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/OrExpression.qll new file mode 100644 index 000000000000..cf38f1b83883 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/OrExpression.qll @@ -0,0 +1,23 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `OrExpression`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.BinaryExpressionImpl::Impl as BinaryExpressionImpl + +/** + * INTERNAL: This module contains the fully generated definition of `OrExpression` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::OrExpression` class directly. + * Use the subclass `OrExpression`, where the following predicates are available. + */ + class OrExpression extends Synth::TOrExpression, BinaryExpressionImpl::BinaryExpression { + override string getAPrimaryQlClass() { result = "OrExpression" } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/OrderElement.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/OrderElement.qll new file mode 100644 index 000000000000..080db62c2908 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/OrderElement.qll @@ -0,0 +1,55 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `OrderElement`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.AstImpl::Impl as AstImpl + +/** + * INTERNAL: This module contains the fully generated definition of `OrderElement` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::OrderElement` class directly. + * Use the subclass `OrderElement`, where the following predicates are available. + */ + class OrderElement extends Synth::TOrderElement, AstImpl::Ast { + /** + * Gets the direction of this order element, if it exists. + */ + string getDirection() { + result = Synth::convertOrderElementToRaw(this).(Raw::OrderElement).getDirection() + } + + /** + * Holds if `getDirection()` exists. + */ + final predicate hasDirection() { exists(this.getDirection()) } + + /** + * Gets the field of this order element, if it exists. + */ + string getField() { + result = Synth::convertOrderElementToRaw(this).(Raw::OrderElement).getField() + } + + /** + * Holds if `getField()` exists. + */ + final predicate hasField() { exists(this.getField()) } + + /** + * Gets the index of this order element, if it exists. + */ + int getIndex() { result = Synth::convertOrderElementToRaw(this).(Raw::OrderElement).getIndex() } + + /** + * Holds if `getIndex()` exists. + */ + final predicate hasIndex() { exists(this.getIndex()) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/ParameterDeclaration.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/ParameterDeclaration.qll new file mode 100644 index 000000000000..8568d45b5a16 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/ParameterDeclaration.qll @@ -0,0 +1,39 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `ParameterDeclaration`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.VariableDeclarationImpl::Impl as VariableDeclarationImpl + +/** + * INTERNAL: This module contains the fully generated definition of `ParameterDeclaration` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::ParameterDeclaration` class directly. + * Use the subclass `ParameterDeclaration`, where the following predicates are available. + */ + class ParameterDeclaration extends Synth::TParameterDeclaration, + VariableDeclarationImpl::VariableDeclaration + { + override string getAPrimaryQlClass() { result = "ParameterDeclaration" } + + /** + * Holds if this parameter declaration is by reference. + */ + predicate isByRef() { + Synth::convertParameterDeclarationToRaw(this).(Raw::ParameterDeclaration).isByRef() + } + + /** + * Holds if this parameter declaration is optional. + */ + predicate isOptional() { + Synth::convertParameterDeclarationToRaw(this).(Raw::ParameterDeclaration).isOptional() + } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/ParentChild.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/ParentChild.qll new file mode 100644 index 000000000000..49cd4c9dbbe5 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/ParentChild.qll @@ -0,0 +1,3962 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated parent/child relationship. + */ + +import codeql.xpp.elements + +private module Impl { + private Element getImmediateChildOfFile(File e, int index, string partialPredicateCall) { none() } + + private Element getImmediateChildOfLocation(Location e, int index, string partialPredicateCall) { + none() + } + + private Element getImmediateChildOfComment(Comment e, int index, string partialPredicateCall) { + none() + } + + private Element getImmediateChildOfArraySpecification( + ArraySpecification e, int index, string partialPredicateCall + ) { + exists(int n, int nIndex1, int nIndex2 | + n = 0 and + nIndex1 = n + 1 and + nIndex2 = nIndex1 + 1 and + ( + none() + or + index = n and result = e.getIndex1() and partialPredicateCall = "Index1()" + or + index = nIndex1 and result = e.getIndex2() and partialPredicateCall = "Index2()" + ) + ) + } + + private Element getImmediateChildOfAttribute(Attribute e, int index, string partialPredicateCall) { + exists(int n, int nNamedParameter, int nParameter | + n = 0 and + nNamedParameter = n + e.getNumberOfNamedParameters() and + nParameter = nNamedParameter + e.getNumberOfParameters() and + ( + none() + or + result = e.getNamedParameter(index - n) and + partialPredicateCall = "NamedParameter(" + (index - n).toString() + ")" + or + result = e.getParameter(index - nNamedParameter) and + partialPredicateCall = "Parameter(" + (index - nNamedParameter).toString() + ")" + ) + ) + } + + private Element getImmediateChildOfAttributeExpression( + AttributeExpression e, int index, string partialPredicateCall + ) { + exists(int n, int nLiteral | + n = 0 and + nLiteral = n + 1 and + ( + none() + or + index = n and result = e.getLiteral() and partialPredicateCall = "Literal()" + ) + ) + } + + private Element getImmediateChildOfAttributeList( + AttributeList e, int index, string partialPredicateCall + ) { + exists(int n, int nAttribute | + n = 0 and + nAttribute = n + e.getNumberOfAttributes() and + ( + none() + or + result = e.getAttribute(index - n) and + partialPredicateCall = "Attribute(" + (index - n).toString() + ")" + ) + ) + } + + private Element getImmediateChildOfAttributeNamedParameterEntry( + AttributeNamedParameterEntry e, int index, string partialPredicateCall + ) { + exists(int n, int nAttributeExpression | + n = 0 and + nAttributeExpression = n + 1 and + ( + none() + or + index = n and + result = e.getAttributeExpression() and + partialPredicateCall = "AttributeExpression()" + ) + ) + } + + private Element getImmediateChildOfClassAccessModifier( + ClassAccessModifier e, int index, string partialPredicateCall + ) { + none() + } + + private Element getImmediateChildOfCompilationUnitRegionEntry( + CompilationUnitRegionEntry e, int index, string partialPredicateCall + ) { + exists(int n, int nComment, int nComment2 | + n = 0 and + nComment = n + 1 and + nComment2 = nComment + 1 and + ( + none() + or + index = n and result = e.getComment() and partialPredicateCall = "Comment()" + or + index = nComment and result = e.getComment2() and partialPredicateCall = "Comment2()" + ) + ) + } + + private Element getImmediateChildOfEvaluationActualParameterEntry( + EvaluationActualParameterEntry e, int index, string partialPredicateCall + ) { + exists(int n, int nExpression | + n = 0 and + nExpression = n + 1 and + ( + none() + or + index = n and result = e.getExpression() and partialPredicateCall = "Expression()" + ) + ) + } + + private Element getImmediateChildOfFieldAssignment( + FieldAssignment e, int index, string partialPredicateCall + ) { + exists(int n, int nExpression | + n = 0 and + nExpression = n + 1 and + ( + none() + or + index = n and result = e.getExpression() and partialPredicateCall = "Expression()" + ) + ) + } + + private Element getImmediateChildOfInsertFieldSpecification( + InsertFieldSpecification e, int index, string partialPredicateCall + ) { + none() + } + + private Element getImmediateChildOfJoinSpecification( + JoinSpecification e, int index, string partialPredicateCall + ) { + exists(int n, int nQuery | + n = 0 and + nQuery = n + 1 and + ( + none() + or + index = n and result = e.getQuery() and partialPredicateCall = "Query()" + ) + ) + } + + private Element getImmediateChildOfModelElementUsingEntry( + ModelElementUsingEntry e, int index, string partialPredicateCall + ) { + none() + } + + private Element getImmediateChildOfModifier(Modifier e, int index, string partialPredicateCall) { + none() + } + + private Element getImmediateChildOfQuery(Query e, int index, string partialPredicateCall) { + exists( + int n, int nCrossCompany, int nGroupByElement, int nJoins, int nOrderByElement, + int nSelection, int nValidTimeState, int nWhere + | + n = 0 and + nCrossCompany = n + 1 and + nGroupByElement = nCrossCompany + e.getNumberOfGroupByElements() and + nJoins = nGroupByElement + 1 and + nOrderByElement = nJoins + e.getNumberOfOrderByElements() and + nSelection = nOrderByElement + 1 and + nValidTimeState = nSelection + 1 and + nWhere = nValidTimeState + 1 and + ( + none() + or + index = n and result = e.getCrossCompany() and partialPredicateCall = "CrossCompany()" + or + result = e.getGroupByElement(index - nCrossCompany) and + partialPredicateCall = "GroupByElement(" + (index - nCrossCompany).toString() + ")" + or + index = nGroupByElement and result = e.getJoins() and partialPredicateCall = "Joins()" + or + result = e.getOrderByElement(index - nJoins) and + partialPredicateCall = "OrderByElement(" + (index - nJoins).toString() + ")" + or + index = nOrderByElement and + result = e.getSelection() and + partialPredicateCall = "Selection()" + or + index = nSelection and + result = e.getValidTimeState() and + partialPredicateCall = "ValidTimeState()" + or + index = nValidTimeState and result = e.getWhere() and partialPredicateCall = "Where()" + ) + ) + } + + private Element getImmediateChildOfQueryDataSource( + QueryDataSource e, int index, string partialPredicateCall + ) { + exists( + int n, int nDataSource, int nGroupBy, int nHaving, int nOrderBy, int nParentDataSource, + int nRange, int nRelation + | + n = 0 and + nDataSource = n + e.getNumberOfDataSources() and + nGroupBy = nDataSource + e.getNumberOfGroupBies() and + nHaving = nGroupBy + e.getNumberOfHavings() and + nOrderBy = nHaving + e.getNumberOfOrderBies() and + nParentDataSource = nOrderBy + 1 and + nRange = nParentDataSource + e.getNumberOfRanges() and + nRelation = nRange + e.getNumberOfRelations() and + ( + none() + or + result = e.getDataSource(index - n) and + partialPredicateCall = "DataSource(" + (index - n).toString() + ")" + or + result = e.getGroupBy(index - nDataSource) and + partialPredicateCall = "GroupBy(" + (index - nDataSource).toString() + ")" + or + result = e.getHaving(index - nGroupBy) and + partialPredicateCall = "Having(" + (index - nGroupBy).toString() + ")" + or + result = e.getOrderBy(index - nHaving) and + partialPredicateCall = "OrderBy(" + (index - nHaving).toString() + ")" + or + index = nOrderBy and + result = e.getParentDataSource() and + partialPredicateCall = "ParentDataSource()" + or + result = e.getRange(index - nParentDataSource) and + partialPredicateCall = "Range(" + (index - nParentDataSource).toString() + ")" + or + result = e.getRelation(index - nRange) and + partialPredicateCall = "Relation(" + (index - nRange).toString() + ")" + ) + ) + } + + private Element getImmediateChildOfQueryDataSourceHaving( + QueryDataSourceHaving e, int index, string partialPredicateCall + ) { + exists(int n, int nSelection | + n = 0 and + nSelection = n + 1 and + ( + none() + or + index = n and result = e.getSelection() and partialPredicateCall = "Selection()" + ) + ) + } + + private Element getImmediateChildOfQueryDataSourceRange( + QueryDataSourceRange e, int index, string partialPredicateCall + ) { + none() + } + + private Element getImmediateChildOfQueryDataSourceRelation( + QueryDataSourceRelation e, int index, string partialPredicateCall + ) { + none() + } + + private Element getImmediateChildOfSwitchCase(SwitchCase e, int index, string partialPredicateCall) { + none() + } + + private Element getImmediateChildOfSwitchStatementCaseEntry( + SwitchStatementCaseEntry e, int index, string partialPredicateCall + ) { + exists(int n, int nCase, int nStatement | + n = 0 and + nCase = n + 1 and + nStatement = nCase + e.getNumberOfStatements() and + ( + none() + or + index = n and result = e.getCase() and partialPredicateCall = "Case()" + or + result = e.getStatement(index - nCase) and + partialPredicateCall = "Statement(" + (index - nCase).toString() + ")" + ) + ) + } + + private Element getImmediateChildOfTryStatementCatchEntry( + TryStatementCatchEntry e, int index, string partialPredicateCall + ) { + exists(int n, int nCatch, int nStatement | + n = 0 and + nCatch = n + 1 and + nStatement = nCatch + 1 and + ( + none() + or + index = n and result = e.getCatch() and partialPredicateCall = "Catch()" + or + index = nCatch and result = e.getStatement() and partialPredicateCall = "Statement()" + ) + ) + } + + private Element getImmediateChildOfUnspecifiedElement( + UnspecifiedElement e, int index, string partialPredicateCall + ) { + none() + } + + private Element getImmediateChildOfAllFieldsSelection( + AllFieldsSelection e, int index, string partialPredicateCall + ) { + none() + } + + private Element getImmediateChildOfAnyType(AnyType e, int index, string partialPredicateCall) { + none() + } + + private Element getImmediateChildOfBooleanType( + BooleanType e, int index, string partialPredicateCall + ) { + none() + } + + private Element getImmediateChildOfBreakStatement( + BreakStatement e, int index, string partialPredicateCall + ) { + none() + } + + private Element getImmediateChildOfBreakpointStatement( + BreakpointStatement e, int index, string partialPredicateCall + ) { + none() + } + + private Element getImmediateChildOfCaseDefault( + CaseDefault e, int index, string partialPredicateCall + ) { + none() + } + + private Element getImmediateChildOfCaseValues(CaseValues e, int index, string partialPredicateCall) { + exists(int n, int nValue | + n = 0 and + nValue = n + e.getNumberOfValues() and + ( + none() + or + result = e.getValue(index - n) and + partialPredicateCall = "Value(" + (index - n).toString() + ")" + ) + ) + } + + private Element getImmediateChildOfCatchAllValues( + CatchAllValues e, int index, string partialPredicateCall + ) { + none() + } + + private Element getImmediateChildOfCatchExpression( + CatchExpression e, int index, string partialPredicateCall + ) { + exists(int n, int nExpression | + n = 0 and + nExpression = n + 1 and + ( + none() + or + index = n and result = e.getExpression() and partialPredicateCall = "Expression()" + ) + ) + } + + private Element getImmediateChildOfCatchUpdateConflict( + CatchUpdateConflict e, int index, string partialPredicateCall + ) { + exists(int n, int nExpression, int nInstance | + n = 0 and + nExpression = n + 1 and + nInstance = nExpression + 1 and + ( + none() + or + index = n and result = e.getExpression() and partialPredicateCall = "Expression()" + or + index = nExpression and result = e.getInstance() and partialPredicateCall = "Instance()" + ) + ) + } + + private Element getImmediateChildOfCompoundStatement( + CompoundStatement e, int index, string partialPredicateCall + ) { + exists(int n, int nContent | + n = 0 and + nContent = n + e.getNumberOfContents() and + ( + none() + or + result = e.getContent(index - n) and + partialPredicateCall = "Content(" + (index - n).toString() + ")" + ) + ) + } + + private Element getImmediateChildOfConditionalExpression( + ConditionalExpression e, int index, string partialPredicateCall + ) { + exists(int n, int nTransformation, int nCondition, int nElsePart, int nIfPart | + n = 0 and + nTransformation = n + 1 and + nCondition = nTransformation + 1 and + nElsePart = nCondition + 1 and + nIfPart = nElsePart + 1 and + ( + none() + or + index = n and result = e.getTransformation() and partialPredicateCall = "Transformation()" + or + index = nTransformation and + result = e.getCondition() and + partialPredicateCall = "Condition()" + or + index = nCondition and result = e.getElsePart() and partialPredicateCall = "ElsePart()" + or + index = nElsePart and result = e.getIfPart() and partialPredicateCall = "IfPart()" + ) + ) + } + + private Element getImmediateChildOfContainerAttributeLiteral( + ContainerAttributeLiteral e, int index, string partialPredicateCall + ) { + exists(int n, int nValue | + n = 0 and + nValue = n + e.getNumberOfValues() and + ( + none() + or + result = e.getValue(index - n) and + partialPredicateCall = "Value(" + (index - n).toString() + ")" + ) + ) + } + + private Element getImmediateChildOfContainerType( + ContainerType e, int index, string partialPredicateCall + ) { + none() + } + + private Element getImmediateChildOfContinueStatement( + ContinueStatement e, int index, string partialPredicateCall + ) { + none() + } + + private Element getImmediateChildOfCrossCompanyAll( + CrossCompanyAll e, int index, string partialPredicateCall + ) { + none() + } + + private Element getImmediateChildOfCrossCompanyContainer( + CrossCompanyContainer e, int index, string partialPredicateCall + ) { + exists(int n, int nContainer | + n = 0 and + nContainer = n + 1 and + ( + none() + or + index = n and result = e.getContainer() and partialPredicateCall = "Container()" + ) + ) + } + + private Element getImmediateChildOfDateTimeType( + DateTimeType e, int index, string partialPredicateCall + ) { + none() + } + + private Element getImmediateChildOfDateType(DateType e, int index, string partialPredicateCall) { + none() + } + + private Element getImmediateChildOfDblType(DblType e, int index, string partialPredicateCall) { + none() + } + + private Element getImmediateChildOfDeleteStatement( + DeleteStatement e, int index, string partialPredicateCall + ) { + exists(int n, int nQuery | + n = 0 and + nQuery = n + 1 and + ( + none() + or + index = n and result = e.getQuery() and partialPredicateCall = "Query()" + ) + ) + } + + private Element getImmediateChildOfDoWhileStatement( + DoWhileStatement e, int index, string partialPredicateCall + ) { + exists(int n, int nCondition, int nStatement | + n = 0 and + nCondition = n + 1 and + nStatement = nCondition + 1 and + ( + none() + or + index = n and result = e.getCondition() and partialPredicateCall = "Condition()" + or + index = nCondition and result = e.getStatement() and partialPredicateCall = "Statement()" + ) + ) + } + + private Element getImmediateChildOfEmptyExpression( + EmptyExpression e, int index, string partialPredicateCall + ) { + exists(int n, int nTransformation | + n = 0 and + nTransformation = n + 1 and + ( + none() + or + index = n and result = e.getTransformation() and partialPredicateCall = "Transformation()" + ) + ) + } + + private Element getImmediateChildOfEmptyStatement( + EmptyStatement e, int index, string partialPredicateCall + ) { + none() + } + + private Element getImmediateChildOfEnumAttributeLiteral( + EnumAttributeLiteral e, int index, string partialPredicateCall + ) { + none() + } + + private Element getImmediateChildOfEnumerationType( + EnumerationType e, int index, string partialPredicateCall + ) { + none() + } + + private Element getImmediateChildOfExplicitSelection( + ExplicitSelection e, int index, string partialPredicateCall + ) { + exists(int n, int nField | + n = 0 and + nField = n + e.getNumberOfFields() and + ( + none() + or + result = e.getField(index - n) and + partialPredicateCall = "Field(" + (index - n).toString() + ")" + ) + ) + } + + private Element getImmediateChildOfExpressionCompilationUnit( + ExpressionCompilationUnit e, int index, string partialPredicateCall + ) { + exists(int n, int nComments, int nRegion, int nExpression | + n = 0 and + nComments = n + 1 and + nRegion = nComments + e.getNumberOfRegions() and + nExpression = nRegion + 1 and + ( + none() + or + index = n and result = e.getComments() and partialPredicateCall = "Comments()" + or + result = e.getRegion(index - nComments) and + partialPredicateCall = "Region(" + (index - nComments).toString() + ")" + or + index = nRegion and result = e.getExpression() and partialPredicateCall = "Expression()" + ) + ) + } + + private Element getImmediateChildOfExpressionQualifier( + ExpressionQualifier e, int index, string partialPredicateCall + ) { + exists(int n, int nExpression | + n = 0 and + nExpression = n + 1 and + ( + none() + or + index = n and result = e.getExpression() and partialPredicateCall = "Expression()" + ) + ) + } + + private Element getImmediateChildOfExpressionStatement( + ExpressionStatement e, int index, string partialPredicateCall + ) { + exists(int n, int nExpression | + n = 0 and + nExpression = n + 1 and + ( + none() + or + index = n and result = e.getExpression() and partialPredicateCall = "Expression()" + ) + ) + } + + private Element getImmediateChildOfFieldSelection( + FieldSelection e, int index, string partialPredicateCall + ) { + none() + } + + private Element getImmediateChildOfFindStatement( + FindStatement e, int index, string partialPredicateCall + ) { + exists(int n, int nQuery | + n = 0 and + nQuery = n + 1 and + ( + none() + or + index = n and result = e.getQuery() and partialPredicateCall = "Query()" + ) + ) + } + + private Element getImmediateChildOfFlushStatement( + FlushStatement e, int index, string partialPredicateCall + ) { + none() + } + + private Element getImmediateChildOfForDeclarationAssign( + ForDeclarationAssign e, int index, string partialPredicateCall + ) { + exists(int n, int nFieldSpecification, int nInitializationDeclaration | + n = 0 and + nFieldSpecification = n + 1 and + nInitializationDeclaration = nFieldSpecification + e.getNumberOfInitializationDeclarations() and + ( + none() + or + index = n and + result = e.getFieldSpecification() and + partialPredicateCall = "FieldSpecification()" + or + result = e.getInitializationDeclaration(index - nFieldSpecification) and + partialPredicateCall = + "InitializationDeclaration(" + (index - nFieldSpecification).toString() + ")" + ) + ) + } + + private Element getImmediateChildOfForFieldPostDecrement( + ForFieldPostDecrement e, int index, string partialPredicateCall + ) { + exists(int n, int nFieldSpecification | + n = 0 and + nFieldSpecification = n + 1 and + ( + none() + or + index = n and + result = e.getFieldSpecification() and + partialPredicateCall = "FieldSpecification()" + ) + ) + } + + private Element getImmediateChildOfForFieldPostIncrement( + ForFieldPostIncrement e, int index, string partialPredicateCall + ) { + exists(int n, int nFieldSpecification | + n = 0 and + nFieldSpecification = n + 1 and + ( + none() + or + index = n and + result = e.getFieldSpecification() and + partialPredicateCall = "FieldSpecification()" + ) + ) + } + + private Element getImmediateChildOfForFieldPreDecrement( + ForFieldPreDecrement e, int index, string partialPredicateCall + ) { + exists(int n, int nFieldSpecification | + n = 0 and + nFieldSpecification = n + 1 and + ( + none() + or + index = n and + result = e.getFieldSpecification() and + partialPredicateCall = "FieldSpecification()" + ) + ) + } + + private Element getImmediateChildOfForFieldPreIncrement( + ForFieldPreIncrement e, int index, string partialPredicateCall + ) { + exists(int n, int nFieldSpecification | + n = 0 and + nFieldSpecification = n + 1 and + ( + none() + or + index = n and + result = e.getFieldSpecification() and + partialPredicateCall = "FieldSpecification()" + ) + ) + } + + private Element getImmediateChildOfForStatement( + ForStatement e, int index, string partialPredicateCall + ) { + exists(int n, int nCondition, int nInitialization, int nStatement, int nUpdate | + n = 0 and + nCondition = n + 1 and + nInitialization = nCondition + 1 and + nStatement = nInitialization + 1 and + nUpdate = nStatement + 1 and + ( + none() + or + index = n and result = e.getCondition() and partialPredicateCall = "Condition()" + or + index = nCondition and + result = e.getInitialization() and + partialPredicateCall = "Initialization()" + or + index = nInitialization and + result = e.getStatement() and + partialPredicateCall = "Statement()" + or + index = nStatement and result = e.getUpdate() and partialPredicateCall = "Update()" + ) + ) + } + + private Element getImmediateChildOfGlobalOrderElement( + GlobalOrderElement e, int index, string partialPredicateCall + ) { + none() + } + + private Element getImmediateChildOfGuidType(GuidType e, int index, string partialPredicateCall) { + none() + } + + private Element getImmediateChildOfIfStatement( + IfStatement e, int index, string partialPredicateCall + ) { + exists(int n, int nCondition, int nConsequent | + n = 0 and + nCondition = n + 1 and + nConsequent = nCondition + 1 and + ( + none() + or + index = n and result = e.getCondition() and partialPredicateCall = "Condition()" + or + index = nCondition and result = e.getConsequent() and partialPredicateCall = "Consequent()" + ) + ) + } + + private Element getImmediateChildOfIfThenElseStatement( + IfThenElseStatement e, int index, string partialPredicateCall + ) { + exists(int n, int nAntecedent, int nCondition, int nConsequent | + n = 0 and + nAntecedent = n + 1 and + nCondition = nAntecedent + 1 and + nConsequent = nCondition + 1 and + ( + none() + or + index = n and result = e.getAntecedent() and partialPredicateCall = "Antecedent()" + or + index = nAntecedent and result = e.getCondition() and partialPredicateCall = "Condition()" + or + index = nCondition and result = e.getConsequent() and partialPredicateCall = "Consequent()" + ) + ) + } + + private Element getImmediateChildOfImplicitSelection( + ImplicitSelection e, int index, string partialPredicateCall + ) { + none() + } + + private Element getImmediateChildOfInsertStatement( + InsertStatement e, int index, string partialPredicateCall + ) { + exists(int n, int nCrossCompany, int nField, int nQuery | + n = 0 and + nCrossCompany = n + 1 and + nField = nCrossCompany + e.getNumberOfFields() and + nQuery = nField + 1 and + ( + none() + or + index = n and result = e.getCrossCompany() and partialPredicateCall = "CrossCompany()" + or + result = e.getField(index - nCrossCompany) and + partialPredicateCall = "Field(" + (index - nCrossCompany).toString() + ")" + or + index = nField and result = e.getQuery() and partialPredicateCall = "Query()" + ) + ) + } + + private Element getImmediateChildOfInt64Type(Int64Type e, int index, string partialPredicateCall) { + none() + } + + private Element getImmediateChildOfIntType(IntType e, int index, string partialPredicateCall) { + none() + } + + private Element getImmediateChildOfIntrinsic(Intrinsic e, int index, string partialPredicateCall) { + exists(int n, int nTransformation | + n = 0 and + nTransformation = n + 1 and + ( + none() + or + index = n and result = e.getTransformation() and partialPredicateCall = "Transformation()" + ) + ) + } + + private Element getImmediateChildOfIntrinsicAttributeLiteral( + IntrinsicAttributeLiteral e, int index, string partialPredicateCall + ) { + none() + } + + private Element getImmediateChildOfLocalDeclarationsStatement( + LocalDeclarationsStatement e, int index, string partialPredicateCall + ) { + exists(int n, int nDeclaration | + n = 0 and + nDeclaration = n + e.getNumberOfDeclarations() and + ( + none() + or + result = e.getDeclaration(index - n) and + partialPredicateCall = "Declaration(" + (index - n).toString() + ")" + ) + ) + } + + private Element getImmediateChildOfMoveCursorStatement( + MoveCursorStatement e, int index, string partialPredicateCall + ) { + exists(int n, int nSelection | + n = 0 and + nSelection = n + 1 and + ( + none() + or + index = n and result = e.getSelection() and partialPredicateCall = "Selection()" + ) + ) + } + + private Element getImmediateChildOfNamedFieldReference( + NamedFieldReference e, int index, string partialPredicateCall + ) { + exists(int n, int nIndex | + n = 0 and + nIndex = n + 1 and + ( + none() + or + index = n and result = e.getIndex() and partialPredicateCall = "Index()" + ) + ) + } + + private Element getImmediateChildOfNewClrArrayExpression( + NewClrArrayExpression e, int index, string partialPredicateCall + ) { + exists(int n, int nTransformation, int nSize, int nTypeArgumentList | + n = 0 and + nTransformation = n + 1 and + nSize = nTransformation + e.getNumberOfSizes() and + nTypeArgumentList = nSize + e.getNumberOfTypeArgumentLists() and + ( + none() + or + index = n and result = e.getTransformation() and partialPredicateCall = "Transformation()" + or + result = e.getSize(index - nTransformation) and + partialPredicateCall = "Size(" + (index - nTransformation).toString() + ")" + or + result = e.getTypeArgumentList(index - nSize) and + partialPredicateCall = "TypeArgumentList(" + (index - nSize).toString() + ")" + ) + ) + } + + private Element getImmediateChildOfNumberedFieldReference( + NumberedFieldReference e, int index, string partialPredicateCall + ) { + exists(int n, int nIndex, int nFieldNumber | + n = 0 and + nIndex = n + 1 and + nFieldNumber = nIndex + 1 and + ( + none() + or + index = n and result = e.getIndex() and partialPredicateCall = "Index()" + or + index = nIndex and result = e.getFieldNumber() and partialPredicateCall = "FieldNumber()" + ) + ) + } + + private Element getImmediateChildOfPlaceholder( + Placeholder e, int index, string partialPredicateCall + ) { + exists(int n, int nTransformation | + n = 0 and + nTransformation = n + 1 and + ( + none() + or + index = n and result = e.getTransformation() and partialPredicateCall = "Transformation()" + ) + ) + } + + private Element getImmediateChildOfPrintStatement( + PrintStatement e, int index, string partialPredicateCall + ) { + exists(int n, int nExpression | + n = 0 and + nExpression = n + e.getNumberOfExpressions() and + ( + none() + or + result = e.getExpression(index - n) and + partialPredicateCall = "Expression(" + (index - n).toString() + ")" + ) + ) + } + + private Element getImmediateChildOfProvidedType( + ProvidedType e, int index, string partialPredicateCall + ) { + exists(int n, int nArgumentList | + n = 0 and + nArgumentList = n + e.getNumberOfArgumentLists() and + ( + none() + or + result = e.getArgumentList(index - n) and + partialPredicateCall = "ArgumentList(" + (index - n).toString() + ")" + ) + ) + } + + private Element getImmediateChildOfQualifiedField( + QualifiedField e, int index, string partialPredicateCall + ) { + exists(int n, int nArrayIndex, int nQualifier | + n = 0 and + nArrayIndex = n + 1 and + nQualifier = nArrayIndex + 1 and + ( + none() + or + index = n and result = e.getArrayIndex() and partialPredicateCall = "ArrayIndex()" + or + index = nArrayIndex and result = e.getQualifier() and partialPredicateCall = "Qualifier()" + ) + ) + } + + private Element getImmediateChildOfQualifiedInstanceName( + QualifiedInstanceName e, int index, string partialPredicateCall + ) { + exists(int n, int nIndex, int nQualifier | + n = 0 and + nIndex = n + 1 and + nQualifier = nIndex + 1 and + ( + none() + or + index = n and result = e.getIndex() and partialPredicateCall = "Index()" + or + index = nIndex and result = e.getQualifier() and partialPredicateCall = "Qualifier()" + ) + ) + } + + private Element getImmediateChildOfQualifiedNumberedField( + QualifiedNumberedField e, int index, string partialPredicateCall + ) { + exists(int n, int nArrayIndex, int nQualifier, int nFieldNumber | + n = 0 and + nArrayIndex = n + 1 and + nQualifier = nArrayIndex + 1 and + nFieldNumber = nQualifier + 1 and + ( + none() + or + index = n and result = e.getArrayIndex() and partialPredicateCall = "ArrayIndex()" + or + index = nArrayIndex and result = e.getQualifier() and partialPredicateCall = "Qualifier()" + or + index = nQualifier and + result = e.getFieldNumber() and + partialPredicateCall = "FieldNumber()" + ) + ) + } + + private Element getImmediateChildOfQualifiedStaticField( + QualifiedStaticField e, int index, string partialPredicateCall + ) { + exists(int n, int nArrayIndex, int nQualifier | + n = 0 and + nArrayIndex = n + 1 and + nQualifier = nArrayIndex + 1 and + ( + none() + or + index = n and result = e.getArrayIndex() and partialPredicateCall = "ArrayIndex()" + or + index = nArrayIndex and result = e.getQualifier() and partialPredicateCall = "Qualifier()" + ) + ) + } + + private Element getImmediateChildOfRetryStatement( + RetryStatement e, int index, string partialPredicateCall + ) { + none() + } + + private Element getImmediateChildOfReturnStatement( + ReturnStatement e, int index, string partialPredicateCall + ) { + exists(int n, int nExpression | + n = 0 and + nExpression = n + 1 and + ( + none() + or + index = n and result = e.getExpression() and partialPredicateCall = "Expression()" + ) + ) + } + + private Element getImmediateChildOfSearchStatement( + SearchStatement e, int index, string partialPredicateCall + ) { + exists(int n, int nQuery, int nStatement | + n = 0 and + nQuery = n + 1 and + nStatement = nQuery + 1 and + ( + none() + or + index = n and result = e.getQuery() and partialPredicateCall = "Query()" + or + index = nQuery and result = e.getStatement() and partialPredicateCall = "Statement()" + ) + ) + } + + private Element getImmediateChildOfSimpleField( + SimpleField e, int index, string partialPredicateCall + ) { + exists(int n, int nArrayIndex, int nQualifier | + n = 0 and + nArrayIndex = n + 1 and + nQualifier = nArrayIndex + 1 and + ( + none() + or + index = n and result = e.getArrayIndex() and partialPredicateCall = "ArrayIndex()" + or + index = nArrayIndex and result = e.getQualifier() and partialPredicateCall = "Qualifier()" + ) + ) + } + + private Element getImmediateChildOfSimpleInstanceName( + SimpleInstanceName e, int index, string partialPredicateCall + ) { + exists(int n, int nIndex | + n = 0 and + nIndex = n + 1 and + ( + none() + or + index = n and result = e.getIndex() and partialPredicateCall = "Index()" + ) + ) + } + + private Element getImmediateChildOfSimpleOrderElement( + SimpleOrderElement e, int index, string partialPredicateCall + ) { + none() + } + + private Element getImmediateChildOfStaticField( + StaticField e, int index, string partialPredicateCall + ) { + exists(int n, int nArrayIndex, int nQualifier | + n = 0 and + nArrayIndex = n + 1 and + nQualifier = nArrayIndex + 1 and + ( + none() + or + index = n and result = e.getArrayIndex() and partialPredicateCall = "ArrayIndex()" + or + index = nArrayIndex and result = e.getQualifier() and partialPredicateCall = "Qualifier()" + ) + ) + } + + private Element getImmediateChildOfSwitchStatement( + SwitchStatement e, int index, string partialPredicateCall + ) { + exists(int n, int nCase, int nSelector | + n = 0 and + nCase = n + e.getNumberOfCases() and + nSelector = nCase + 1 and + ( + none() + or + result = e.getCase(index - n) and + partialPredicateCall = "Case(" + (index - n).toString() + ")" + or + index = nCase and result = e.getSelector() and partialPredicateCall = "Selector()" + ) + ) + } + + private Element getImmediateChildOfTableLookupExpression( + TableLookupExpression e, int index, string partialPredicateCall + ) { + exists(int n, int nTransformation, int nField, int nQuery | + n = 0 and + nTransformation = n + 1 and + nField = nTransformation + 1 and + nQuery = nField + 1 and + ( + none() + or + index = n and result = e.getTransformation() and partialPredicateCall = "Transformation()" + or + index = nTransformation and result = e.getField() and partialPredicateCall = "Field()" + or + index = nField and result = e.getQuery() and partialPredicateCall = "Query()" + ) + ) + } + + private Element getImmediateChildOfThrowStatement( + ThrowStatement e, int index, string partialPredicateCall + ) { + exists(int n, int nException | + n = 0 and + nException = n + 1 and + ( + none() + or + index = n and result = e.getException() and partialPredicateCall = "Exception()" + ) + ) + } + + private Element getImmediateChildOfTryStatement( + TryStatement e, int index, string partialPredicateCall + ) { + exists(int n, int nCatch, int nFinally, int nStatement | + n = 0 and + nCatch = n + e.getNumberOfCatches() and + nFinally = nCatch + 1 and + nStatement = nFinally + 1 and + ( + none() + or + result = e.getCatch(index - n) and + partialPredicateCall = "Catch(" + (index - n).toString() + ")" + or + index = nCatch and result = e.getFinally() and partialPredicateCall = "Finally()" + or + index = nFinally and result = e.getStatement() and partialPredicateCall = "Statement()" + ) + ) + } + + private Element getImmediateChildOfUncheckedStatement( + UncheckedStatement e, int index, string partialPredicateCall + ) { + exists(int n, int nExpression, int nStatement | + n = 0 and + nExpression = n + 1 and + nStatement = nExpression + 1 and + ( + none() + or + index = n and result = e.getExpression() and partialPredicateCall = "Expression()" + or + index = nExpression and result = e.getStatement() and partialPredicateCall = "Statement()" + ) + ) + } + + private Element getImmediateChildOfUpdateStatement( + UpdateStatement e, int index, string partialPredicateCall + ) { + exists(int n, int nCrossCompany, int nFieldAssignment, int nJoins, int nWhere | + n = 0 and + nCrossCompany = n + 1 and + nFieldAssignment = nCrossCompany + e.getNumberOfFieldAssignments() and + nJoins = nFieldAssignment + 1 and + nWhere = nJoins + 1 and + ( + none() + or + index = n and result = e.getCrossCompany() and partialPredicateCall = "CrossCompany()" + or + result = e.getFieldAssignment(index - nCrossCompany) and + partialPredicateCall = "FieldAssignment(" + (index - nCrossCompany).toString() + ")" + or + index = nFieldAssignment and result = e.getJoins() and partialPredicateCall = "Joins()" + or + index = nJoins and result = e.getWhere() and partialPredicateCall = "Where()" + ) + ) + } + + private Element getImmediateChildOfUsingStatement( + UsingStatement e, int index, string partialPredicateCall + ) { + exists(int n, int nDisposableObjectInitializer, int nStatement | + n = 0 and + nDisposableObjectInitializer = n + e.getNumberOfDisposableObjectInitializers() and + nStatement = nDisposableObjectInitializer + 1 and + ( + none() + or + result = e.getDisposableObjectInitializer(index - n) and + partialPredicateCall = "DisposableObjectInitializer(" + (index - n).toString() + ")" + or + index = nDisposableObjectInitializer and + result = e.getStatement() and + partialPredicateCall = "Statement()" + ) + ) + } + + private Element getImmediateChildOfValidTimeStateDate( + ValidTimeStateDate e, int index, string partialPredicateCall + ) { + none() + } + + private Element getImmediateChildOfValidTimeStateRange( + ValidTimeStateRange e, int index, string partialPredicateCall + ) { + none() + } + + private Element getImmediateChildOfVarType(VarType e, int index, string partialPredicateCall) { + none() + } + + private Element getImmediateChildOfVoidType(VoidType e, int index, string partialPredicateCall) { + none() + } + + private Element getImmediateChildOfWhileStatement( + WhileStatement e, int index, string partialPredicateCall + ) { + exists(int n, int nCondition, int nStatement | + n = 0 and + nCondition = n + 1 and + nStatement = nCondition + 1 and + ( + none() + or + index = n and result = e.getCondition() and partialPredicateCall = "Condition()" + or + index = nCondition and result = e.getStatement() and partialPredicateCall = "Statement()" + ) + ) + } + + private Element getImmediateChildOfXppTypeCompilationUnit( + XppTypeCompilationUnit e, int index, string partialPredicateCall + ) { + exists(int n, int nComments, int nRegion, int nType | + n = 0 and + nComments = n + 1 and + nRegion = nComments + e.getNumberOfRegions() and + nType = nRegion + 1 and + ( + none() + or + index = n and result = e.getComments() and partialPredicateCall = "Comments()" + or + result = e.getRegion(index - nComments) and + partialPredicateCall = "Region(" + (index - nComments).toString() + ")" + or + index = nRegion and result = e.getType() and partialPredicateCall = "Type()" + ) + ) + } + + private Element getImmediateChildOfAddExpression( + AddExpression e, int index, string partialPredicateCall + ) { + exists(int n, int nTransformation, int nLeft, int nRight | + n = 0 and + nTransformation = n + 1 and + nLeft = nTransformation + 1 and + nRight = nLeft + 1 and + ( + none() + or + index = n and result = e.getTransformation() and partialPredicateCall = "Transformation()" + or + index = nTransformation and result = e.getLeft() and partialPredicateCall = "Left()" + or + index = nLeft and result = e.getRight() and partialPredicateCall = "Right()" + ) + ) + } + + private Element getImmediateChildOfAndExpression( + AndExpression e, int index, string partialPredicateCall + ) { + exists(int n, int nTransformation, int nLeft, int nRight | + n = 0 and + nTransformation = n + 1 and + nLeft = nTransformation + 1 and + nRight = nLeft + 1 and + ( + none() + or + index = n and result = e.getTransformation() and partialPredicateCall = "Transformation()" + or + index = nTransformation and result = e.getLeft() and partialPredicateCall = "Left()" + or + index = nLeft and result = e.getRight() and partialPredicateCall = "Right()" + ) + ) + } + + private Element getImmediateChildOfAsClrExpression( + AsClrExpression e, int index, string partialPredicateCall + ) { + exists(int n, int nTransformation, int nExpression | + n = 0 and + nTransformation = n + 1 and + nExpression = nTransformation + 1 and + ( + none() + or + index = n and result = e.getTransformation() and partialPredicateCall = "Transformation()" + or + index = nTransformation and + result = e.getExpression() and + partialPredicateCall = "Expression()" + ) + ) + } + + private Element getImmediateChildOfAsExpression( + AsExpression e, int index, string partialPredicateCall + ) { + exists(int n, int nTransformation, int nExpression | + n = 0 and + nTransformation = n + 1 and + nExpression = nTransformation + 1 and + ( + none() + or + index = n and result = e.getTransformation() and partialPredicateCall = "Transformation()" + or + index = nTransformation and + result = e.getExpression() and + partialPredicateCall = "Expression()" + ) + ) + } + + private Element getImmediateChildOfAssignMultipleFieldStatement( + AssignMultipleFieldStatement e, int index, string partialPredicateCall + ) { + exists(int n, int nExpression, int nField | + n = 0 and + nExpression = n + 1 and + nField = nExpression + e.getNumberOfFields() and + ( + none() + or + index = n and result = e.getExpression() and partialPredicateCall = "Expression()" + or + result = e.getField(index - nExpression) and + partialPredicateCall = "Field(" + (index - nExpression).toString() + ")" + ) + ) + } + + private Element getImmediateChildOfAvgAggregateSelection( + AvgAggregateSelection e, int index, string partialPredicateCall + ) { + none() + } + + private Element getImmediateChildOfBooleanAttributeLiteral( + BooleanAttributeLiteral e, int index, string partialPredicateCall + ) { + none() + } + + private Element getImmediateChildOfChangeCompanyStatement( + ChangeCompanyStatement e, int index, string partialPredicateCall + ) { + exists(int n, int nExpression, int nStatement | + n = 0 and + nExpression = n + 1 and + nStatement = nExpression + 1 and + ( + none() + or + index = n and result = e.getExpression() and partialPredicateCall = "Expression()" + or + index = nExpression and result = e.getStatement() and partialPredicateCall = "Statement()" + ) + ) + } + + private Element getImmediateChildOfClrEnumerationLiteralExpression( + ClrEnumerationLiteralExpression e, int index, string partialPredicateCall + ) { + exists(int n, int nTransformation | + n = 0 and + nTransformation = n + 1 and + ( + none() + or + index = n and result = e.getTransformation() and partialPredicateCall = "Transformation()" + ) + ) + } + + private Element getImmediateChildOfClrType(ClrType e, int index, string partialPredicateCall) { + exists(int n, int nTypeArgumentList | + n = 0 and + nTypeArgumentList = n + e.getNumberOfTypeArgumentLists() and + ( + none() + or + result = e.getTypeArgumentList(index - n) and + partialPredicateCall = "TypeArgumentList(" + (index - n).toString() + ")" + ) + ) + } + + private Element getImmediateChildOfContainerLiteralExpression( + ContainerLiteralExpression e, int index, string partialPredicateCall + ) { + exists(int n, int nTransformation, int nValue | + n = 0 and + nTransformation = n + 1 and + nValue = nTransformation + e.getNumberOfValues() and + ( + none() + or + index = n and result = e.getTransformation() and partialPredicateCall = "Transformation()" + or + result = e.getValue(index - nTransformation) and + partialPredicateCall = "Value(" + (index - nTransformation).toString() + ")" + ) + ) + } + + private Element getImmediateChildOfCountAggregateSelection( + CountAggregateSelection e, int index, string partialPredicateCall + ) { + none() + } + + private Element getImmediateChildOfDateAttributeLiteral( + DateAttributeLiteral e, int index, string partialPredicateCall + ) { + none() + } + + private Element getImmediateChildOfDateTimeAttributeLiteral( + DateTimeAttributeLiteral e, int index, string partialPredicateCall + ) { + none() + } + + private Element getImmediateChildOfDblAttributeLiteral( + DblAttributeLiteral e, int index, string partialPredicateCall + ) { + none() + } + + private Element getImmediateChildOfDelegate(Delegate e, int index, string partialPredicateCall) { + exists( + int n, int nComments, int nRegion, int nAttributes, int nModifierList, int nParameter, + int nType + | + n = 0 and + nComments = n + 1 and + nRegion = nComments + e.getNumberOfRegions() and + nAttributes = nRegion + 1 and + nModifierList = nAttributes + e.getNumberOfModifierLists() and + nParameter = nModifierList + e.getNumberOfParameters() and + nType = nParameter + 1 and + ( + none() + or + index = n and result = e.getComments() and partialPredicateCall = "Comments()" + or + result = e.getRegion(index - nComments) and + partialPredicateCall = "Region(" + (index - nComments).toString() + ")" + or + index = nRegion and result = e.getAttributes() and partialPredicateCall = "Attributes()" + or + result = e.getModifierList(index - nAttributes) and + partialPredicateCall = "ModifierList(" + (index - nAttributes).toString() + ")" + or + result = e.getParameter(index - nModifierList) and + partialPredicateCall = "Parameter(" + (index - nModifierList).toString() + ")" + or + index = nParameter and result = e.getType() and partialPredicateCall = "Type()" + ) + ) + } + + private Element getImmediateChildOfDivideExpression( + DivideExpression e, int index, string partialPredicateCall + ) { + exists(int n, int nTransformation, int nLeft, int nRight | + n = 0 and + nTransformation = n + 1 and + nLeft = nTransformation + 1 and + nRight = nLeft + 1 and + ( + none() + or + index = n and result = e.getTransformation() and partialPredicateCall = "Transformation()" + or + index = nTransformation and result = e.getLeft() and partialPredicateCall = "Left()" + or + index = nLeft and result = e.getRight() and partialPredicateCall = "Right()" + ) + ) + } + + private Element getImmediateChildOfEnumerationLiteralExpression( + EnumerationLiteralExpression e, int index, string partialPredicateCall + ) { + exists(int n, int nTransformation | + n = 0 and + nTransformation = n + 1 and + ( + none() + or + index = n and result = e.getTransformation() and partialPredicateCall = "Transformation()" + ) + ) + } + + private Element getImmediateChildOfFieldExpressionInternal( + FieldExpressionInternal e, int index, string partialPredicateCall + ) { + exists(int n, int nTransformation, int nField | + n = 0 and + nTransformation = n + 1 and + nField = nTransformation + 1 and + ( + none() + or + index = n and result = e.getTransformation() and partialPredicateCall = "Transformation()" + or + index = nTransformation and result = e.getField() and partialPredicateCall = "Field()" + ) + ) + } + + private Element getImmediateChildOfForFieldAssign( + ForFieldAssign e, int index, string partialPredicateCall + ) { + exists(int n, int nFieldSpecification, int nExpression | + n = 0 and + nFieldSpecification = n + 1 and + nExpression = nFieldSpecification + 1 and + ( + none() + or + index = n and + result = e.getFieldSpecification() and + partialPredicateCall = "FieldSpecification()" + or + index = nFieldSpecification and + result = e.getExpression() and + partialPredicateCall = "Expression()" + ) + ) + } + + private Element getImmediateChildOfForFieldDecrementAssign( + ForFieldDecrementAssign e, int index, string partialPredicateCall + ) { + exists(int n, int nFieldSpecification, int nExpression | + n = 0 and + nFieldSpecification = n + 1 and + nExpression = nFieldSpecification + 1 and + ( + none() + or + index = n and + result = e.getFieldSpecification() and + partialPredicateCall = "FieldSpecification()" + or + index = nFieldSpecification and + result = e.getExpression() and + partialPredicateCall = "Expression()" + ) + ) + } + + private Element getImmediateChildOfForFieldIncrementAssign( + ForFieldIncrementAssign e, int index, string partialPredicateCall + ) { + exists(int n, int nFieldSpecification, int nExpression | + n = 0 and + nFieldSpecification = n + 1 and + nExpression = nFieldSpecification + 1 and + ( + none() + or + index = n and + result = e.getFieldSpecification() and + partialPredicateCall = "FieldSpecification()" + or + index = nFieldSpecification and + result = e.getExpression() and + partialPredicateCall = "Expression()" + ) + ) + } + + private Element getImmediateChildOfFormModelElement( + FormModelElement e, int index, string partialPredicateCall + ) { + exists( + int n, int nComments, int nRegion, int nBaseMethod, int nExtendGenericParameter, int nMethod, + int nModifierList, int nNestedClass, int nUsing, int nBehavior, int nControl, int nDataSource + | + n = 0 and + nComments = n + 1 and + nRegion = nComments + e.getNumberOfRegions() and + nBaseMethod = nRegion + e.getNumberOfBaseMethods() and + nExtendGenericParameter = nBaseMethod + e.getNumberOfExtendGenericParameters() and + nMethod = nExtendGenericParameter + e.getNumberOfMethods() and + nModifierList = nMethod + e.getNumberOfModifierLists() and + nNestedClass = nModifierList + e.getNumberOfNestedClasses() and + nUsing = nNestedClass + e.getNumberOfUsings() and + nBehavior = nUsing + 1 and + nControl = nBehavior + e.getNumberOfControls() and + nDataSource = nControl + e.getNumberOfDataSources() and + ( + none() + or + index = n and result = e.getComments() and partialPredicateCall = "Comments()" + or + result = e.getRegion(index - nComments) and + partialPredicateCall = "Region(" + (index - nComments).toString() + ")" + or + result = e.getBaseMethod(index - nRegion) and + partialPredicateCall = "BaseMethod(" + (index - nRegion).toString() + ")" + or + result = e.getExtendGenericParameter(index - nBaseMethod) and + partialPredicateCall = "ExtendGenericParameter(" + (index - nBaseMethod).toString() + ")" + or + result = e.getMethod(index - nExtendGenericParameter) and + partialPredicateCall = "Method(" + (index - nExtendGenericParameter).toString() + ")" + or + result = e.getModifierList(index - nMethod) and + partialPredicateCall = "ModifierList(" + (index - nMethod).toString() + ")" + or + result = e.getNestedClass(index - nModifierList) and + partialPredicateCall = "NestedClass(" + (index - nModifierList).toString() + ")" + or + result = e.getUsing(index - nNestedClass) and + partialPredicateCall = "Using(" + (index - nNestedClass).toString() + ")" + or + index = nUsing and result = e.getBehavior() and partialPredicateCall = "Behavior()" + or + result = e.getControl(index - nBehavior) and + partialPredicateCall = "Control(" + (index - nBehavior).toString() + ")" + or + result = e.getDataSource(index - nControl) and + partialPredicateCall = "DataSource(" + (index - nControl).toString() + ")" + ) + ) + } + + private Element getImmediateChildOfGuidAttributeLiteral( + GuidAttributeLiteral e, int index, string partialPredicateCall + ) { + none() + } + + private Element getImmediateChildOfInExpression( + InExpression e, int index, string partialPredicateCall + ) { + exists(int n, int nTransformation, int nLeft, int nRight | + n = 0 and + nTransformation = n + 1 and + nLeft = nTransformation + 1 and + nRight = nLeft + 1 and + ( + none() + or + index = n and result = e.getTransformation() and partialPredicateCall = "Transformation()" + or + index = nTransformation and result = e.getLeft() and partialPredicateCall = "Left()" + or + index = nLeft and result = e.getRight() and partialPredicateCall = "Right()" + ) + ) + } + + private Element getImmediateChildOfInt64AttributeLiteral( + Int64AttributeLiteral e, int index, string partialPredicateCall + ) { + none() + } + + private Element getImmediateChildOfIntAttributeLiteral( + IntAttributeLiteral e, int index, string partialPredicateCall + ) { + none() + } + + private Element getImmediateChildOfIntegerDivideExpression( + IntegerDivideExpression e, int index, string partialPredicateCall + ) { + exists(int n, int nTransformation, int nLeft, int nRight | + n = 0 and + nTransformation = n + 1 and + nLeft = nTransformation + 1 and + nRight = nLeft + 1 and + ( + none() + or + index = n and result = e.getTransformation() and partialPredicateCall = "Transformation()" + or + index = nTransformation and result = e.getLeft() and partialPredicateCall = "Left()" + or + index = nLeft and result = e.getRight() and partialPredicateCall = "Right()" + ) + ) + } + + private Element getImmediateChildOfIsClrExpression( + IsClrExpression e, int index, string partialPredicateCall + ) { + exists(int n, int nTransformation, int nExpression | + n = 0 and + nTransformation = n + 1 and + nExpression = nTransformation + 1 and + ( + none() + or + index = n and result = e.getTransformation() and partialPredicateCall = "Transformation()" + or + index = nTransformation and + result = e.getExpression() and + partialPredicateCall = "Expression()" + ) + ) + } + + private Element getImmediateChildOfIsExpression( + IsExpression e, int index, string partialPredicateCall + ) { + exists(int n, int nTransformation, int nExpression | + n = 0 and + nTransformation = n + 1 and + nExpression = nTransformation + 1 and + ( + none() + or + index = n and result = e.getTransformation() and partialPredicateCall = "Transformation()" + or + index = nTransformation and + result = e.getExpression() and + partialPredicateCall = "Expression()" + ) + ) + } + + private Element getImmediateChildOfMaxAggregateSelection( + MaxAggregateSelection e, int index, string partialPredicateCall + ) { + none() + } + + private Element getImmediateChildOfMethod(Method e, int index, string partialPredicateCall) { + exists( + int n, int nComments, int nRegion, int nAttributes, int nModifierList, int nParameter, + int nType, int nDeclarationsAndStatement, int nLocal, int nStatement + | + n = 0 and + nComments = n + 1 and + nRegion = nComments + e.getNumberOfRegions() and + nAttributes = nRegion + 1 and + nModifierList = nAttributes + e.getNumberOfModifierLists() and + nParameter = nModifierList + e.getNumberOfParameters() and + nType = nParameter + 1 and + nDeclarationsAndStatement = nType + e.getNumberOfDeclarationsAndStatements() and + nLocal = nDeclarationsAndStatement + e.getNumberOfLocals() and + nStatement = nLocal + e.getNumberOfStatements() and + ( + none() + or + index = n and result = e.getComments() and partialPredicateCall = "Comments()" + or + result = e.getRegion(index - nComments) and + partialPredicateCall = "Region(" + (index - nComments).toString() + ")" + or + index = nRegion and result = e.getAttributes() and partialPredicateCall = "Attributes()" + or + result = e.getModifierList(index - nAttributes) and + partialPredicateCall = "ModifierList(" + (index - nAttributes).toString() + ")" + or + result = e.getParameter(index - nModifierList) and + partialPredicateCall = "Parameter(" + (index - nModifierList).toString() + ")" + or + index = nParameter and result = e.getType() and partialPredicateCall = "Type()" + or + result = e.getDeclarationsAndStatement(index - nType) and + partialPredicateCall = "DeclarationsAndStatement(" + (index - nType).toString() + ")" + or + result = e.getLocal(index - nDeclarationsAndStatement) and + partialPredicateCall = "Local(" + (index - nDeclarationsAndStatement).toString() + ")" + or + result = e.getStatement(index - nLocal) and + partialPredicateCall = "Statement(" + (index - nLocal).toString() + ")" + ) + ) + } + + private Element getImmediateChildOfMinAggregateSelection( + MinAggregateSelection e, int index, string partialPredicateCall + ) { + none() + } + + private Element getImmediateChildOfModExpression( + ModExpression e, int index, string partialPredicateCall + ) { + exists(int n, int nTransformation, int nLeft, int nRight | + n = 0 and + nTransformation = n + 1 and + nLeft = nTransformation + 1 and + nRight = nLeft + 1 and + ( + none() + or + index = n and result = e.getTransformation() and partialPredicateCall = "Transformation()" + or + index = nTransformation and result = e.getLeft() and partialPredicateCall = "Left()" + or + index = nLeft and result = e.getRight() and partialPredicateCall = "Right()" + ) + ) + } + + private Element getImmediateChildOfMultiplyExpression( + MultiplyExpression e, int index, string partialPredicateCall + ) { + exists(int n, int nTransformation, int nLeft, int nRight | + n = 0 and + nTransformation = n + 1 and + nLeft = nTransformation + 1 and + nRight = nLeft + 1 and + ( + none() + or + index = n and result = e.getTransformation() and partialPredicateCall = "Transformation()" + or + index = nTransformation and result = e.getLeft() and partialPredicateCall = "Left()" + or + index = nLeft and result = e.getRight() and partialPredicateCall = "Right()" + ) + ) + } + + private Element getImmediateChildOfNewCall(NewCall e, int index, string partialPredicateCall) { + exists(int n, int nTransformation, int nActualParameter, int nType | + n = 0 and + nTransformation = n + 1 and + nActualParameter = nTransformation + e.getNumberOfActualParameters() and + nType = nActualParameter + 1 and + ( + none() + or + index = n and result = e.getTransformation() and partialPredicateCall = "Transformation()" + or + result = e.getActualParameter(index - nTransformation) and + partialPredicateCall = "ActualParameter(" + (index - nTransformation).toString() + ")" + or + index = nActualParameter and result = e.getType() and partialPredicateCall = "Type()" + ) + ) + } + + private Element getImmediateChildOfNextExpression( + NextExpression e, int index, string partialPredicateCall + ) { + exists(int n, int nTransformation, int nActualParameter | + n = 0 and + nTransformation = n + 1 and + nActualParameter = nTransformation + e.getNumberOfActualParameters() and + ( + none() + or + index = n and result = e.getTransformation() and partialPredicateCall = "Transformation()" + or + result = e.getActualParameter(index - nTransformation) and + partialPredicateCall = "ActualParameter(" + (index - nTransformation).toString() + ")" + ) + ) + } + + private Element getImmediateChildOfNotExpression( + NotExpression e, int index, string partialPredicateCall + ) { + exists(int n, int nTransformation, int nExpression | + n = 0 and + nTransformation = n + 1 and + nExpression = nTransformation + 1 and + ( + none() + or + index = n and result = e.getTransformation() and partialPredicateCall = "Transformation()" + or + index = nTransformation and + result = e.getExpression() and + partialPredicateCall = "Expression()" + ) + ) + } + + private Element getImmediateChildOfNullLiteralExpression( + NullLiteralExpression e, int index, string partialPredicateCall + ) { + exists(int n, int nTransformation | + n = 0 and + nTransformation = n + 1 and + ( + none() + or + index = n and result = e.getTransformation() and partialPredicateCall = "Transformation()" + ) + ) + } + + private Element getImmediateChildOfOrExpression( + OrExpression e, int index, string partialPredicateCall + ) { + exists(int n, int nTransformation, int nLeft, int nRight | + n = 0 and + nTransformation = n + 1 and + nLeft = nTransformation + 1 and + nRight = nLeft + 1 and + ( + none() + or + index = n and result = e.getTransformation() and partialPredicateCall = "Transformation()" + or + index = nTransformation and result = e.getLeft() and partialPredicateCall = "Left()" + or + index = nLeft and result = e.getRight() and partialPredicateCall = "Right()" + ) + ) + } + + private Element getImmediateChildOfPhysicalAndExpression( + PhysicalAndExpression e, int index, string partialPredicateCall + ) { + exists(int n, int nTransformation, int nLeft, int nRight | + n = 0 and + nTransformation = n + 1 and + nLeft = nTransformation + 1 and + nRight = nLeft + 1 and + ( + none() + or + index = n and result = e.getTransformation() and partialPredicateCall = "Transformation()" + or + index = nTransformation and result = e.getLeft() and partialPredicateCall = "Left()" + or + index = nLeft and result = e.getRight() and partialPredicateCall = "Right()" + ) + ) + } + + private Element getImmediateChildOfPhysicalNotExpression( + PhysicalNotExpression e, int index, string partialPredicateCall + ) { + exists(int n, int nTransformation, int nExpression | + n = 0 and + nTransformation = n + 1 and + nExpression = nTransformation + 1 and + ( + none() + or + index = n and result = e.getTransformation() and partialPredicateCall = "Transformation()" + or + index = nTransformation and + result = e.getExpression() and + partialPredicateCall = "Expression()" + ) + ) + } + + private Element getImmediateChildOfPhysicalOrExpression( + PhysicalOrExpression e, int index, string partialPredicateCall + ) { + exists(int n, int nTransformation, int nLeft, int nRight | + n = 0 and + nTransformation = n + 1 and + nLeft = nTransformation + 1 and + nRight = nLeft + 1 and + ( + none() + or + index = n and result = e.getTransformation() and partialPredicateCall = "Transformation()" + or + index = nTransformation and result = e.getLeft() and partialPredicateCall = "Left()" + or + index = nLeft and result = e.getRight() and partialPredicateCall = "Right()" + ) + ) + } + + private Element getImmediateChildOfPhysicalXorExpression( + PhysicalXorExpression e, int index, string partialPredicateCall + ) { + exists(int n, int nTransformation, int nLeft, int nRight | + n = 0 and + nTransformation = n + 1 and + nLeft = nTransformation + 1 and + nRight = nLeft + 1 and + ( + none() + or + index = n and result = e.getTransformation() and partialPredicateCall = "Transformation()" + or + index = nTransformation and result = e.getLeft() and partialPredicateCall = "Left()" + or + index = nLeft and result = e.getRight() and partialPredicateCall = "Right()" + ) + ) + } + + private Element getImmediateChildOfProvidedTypeStaticCall( + ProvidedTypeStaticCall e, int index, string partialPredicateCall + ) { + exists(int n, int nTransformation, int nActualParameter, int nProvidedType | + n = 0 and + nTransformation = n + 1 and + nActualParameter = nTransformation + e.getNumberOfActualParameters() and + nProvidedType = nActualParameter + 1 and + ( + none() + or + index = n and result = e.getTransformation() and partialPredicateCall = "Transformation()" + or + result = e.getActualParameter(index - nTransformation) and + partialPredicateCall = "ActualParameter(" + (index - nTransformation).toString() + ")" + or + index = nActualParameter and + result = e.getProvidedType() and + partialPredicateCall = "ProvidedType()" + ) + ) + } + + private Element getImmediateChildOfQualifiedStaticFieldExpression( + QualifiedStaticFieldExpression e, int index, string partialPredicateCall + ) { + exists(int n, int nTransformation, int nField | + n = 0 and + nTransformation = n + 1 and + nField = nTransformation + 1 and + ( + none() + or + index = n and result = e.getTransformation() and partialPredicateCall = "Transformation()" + or + index = nTransformation and result = e.getField() and partialPredicateCall = "Field()" + ) + ) + } + + private Element getImmediateChildOfQueryModelElement( + QueryModelElement e, int index, string partialPredicateCall + ) { + exists( + int n, int nComments, int nRegion, int nBaseMethod, int nExtendGenericParameter, int nMethod, + int nModifierList, int nNestedClass, int nUsing, int nBehavior, int nDataSourceList, + int nDataSource + | + n = 0 and + nComments = n + 1 and + nRegion = nComments + e.getNumberOfRegions() and + nBaseMethod = nRegion + e.getNumberOfBaseMethods() and + nExtendGenericParameter = nBaseMethod + e.getNumberOfExtendGenericParameters() and + nMethod = nExtendGenericParameter + e.getNumberOfMethods() and + nModifierList = nMethod + e.getNumberOfModifierLists() and + nNestedClass = nModifierList + e.getNumberOfNestedClasses() and + nUsing = nNestedClass + e.getNumberOfUsings() and + nBehavior = nUsing + 1 and + nDataSourceList = nBehavior + e.getNumberOfDataSourceLists() and + nDataSource = nDataSourceList + e.getNumberOfDataSources() and + ( + none() + or + index = n and result = e.getComments() and partialPredicateCall = "Comments()" + or + result = e.getRegion(index - nComments) and + partialPredicateCall = "Region(" + (index - nComments).toString() + ")" + or + result = e.getBaseMethod(index - nRegion) and + partialPredicateCall = "BaseMethod(" + (index - nRegion).toString() + ")" + or + result = e.getExtendGenericParameter(index - nBaseMethod) and + partialPredicateCall = "ExtendGenericParameter(" + (index - nBaseMethod).toString() + ")" + or + result = e.getMethod(index - nExtendGenericParameter) and + partialPredicateCall = "Method(" + (index - nExtendGenericParameter).toString() + ")" + or + result = e.getModifierList(index - nMethod) and + partialPredicateCall = "ModifierList(" + (index - nMethod).toString() + ")" + or + result = e.getNestedClass(index - nModifierList) and + partialPredicateCall = "NestedClass(" + (index - nModifierList).toString() + ")" + or + result = e.getUsing(index - nNestedClass) and + partialPredicateCall = "Using(" + (index - nNestedClass).toString() + ")" + or + index = nUsing and result = e.getBehavior() and partialPredicateCall = "Behavior()" + or + result = e.getDataSourceList(index - nBehavior) and + partialPredicateCall = "DataSourceList(" + (index - nBehavior).toString() + ")" + or + result = e.getDataSource(index - nDataSourceList) and + partialPredicateCall = "DataSource(" + (index - nDataSourceList).toString() + ")" + ) + ) + } + + private Element getImmediateChildOfShiftLeftExpression( + ShiftLeftExpression e, int index, string partialPredicateCall + ) { + exists(int n, int nTransformation, int nLeft, int nRight | + n = 0 and + nTransformation = n + 1 and + nLeft = nTransformation + 1 and + nRight = nLeft + 1 and + ( + none() + or + index = n and result = e.getTransformation() and partialPredicateCall = "Transformation()" + or + index = nTransformation and result = e.getLeft() and partialPredicateCall = "Left()" + or + index = nLeft and result = e.getRight() and partialPredicateCall = "Right()" + ) + ) + } + + private Element getImmediateChildOfShiftRightExpression( + ShiftRightExpression e, int index, string partialPredicateCall + ) { + exists(int n, int nTransformation, int nLeft, int nRight | + n = 0 and + nTransformation = n + 1 and + nLeft = nTransformation + 1 and + nRight = nLeft + 1 and + ( + none() + or + index = n and result = e.getTransformation() and partialPredicateCall = "Transformation()" + or + index = nTransformation and result = e.getLeft() and partialPredicateCall = "Left()" + or + index = nLeft and result = e.getRight() and partialPredicateCall = "Right()" + ) + ) + } + + private Element getImmediateChildOfSimpleQualifierInternal( + SimpleQualifierInternal e, int index, string partialPredicateCall + ) { + none() + } + + private Element getImmediateChildOfStaticQualifier( + StaticQualifier e, int index, string partialPredicateCall + ) { + exists(int n, int nClassTypeArgumentList | + n = 0 and + nClassTypeArgumentList = n + e.getNumberOfClassTypeArgumentLists() and + ( + none() + or + result = e.getClassTypeArgumentList(index - n) and + partialPredicateCall = "ClassTypeArgumentList(" + (index - n).toString() + ")" + ) + ) + } + + private Element getImmediateChildOfStringAttributeLiteral( + StringAttributeLiteral e, int index, string partialPredicateCall + ) { + none() + } + + private Element getImmediateChildOfStringLengthType( + StringLengthType e, int index, string partialPredicateCall + ) { + none() + } + + private Element getImmediateChildOfStringTypeInternal( + StringTypeInternal e, int index, string partialPredicateCall + ) { + none() + } + + private Element getImmediateChildOfSubtractExpression( + SubtractExpression e, int index, string partialPredicateCall + ) { + exists(int n, int nTransformation, int nLeft, int nRight | + n = 0 and + nTransformation = n + 1 and + nLeft = nTransformation + 1 and + nRight = nLeft + 1 and + ( + none() + or + index = n and result = e.getTransformation() and partialPredicateCall = "Transformation()" + or + index = nTransformation and result = e.getLeft() and partialPredicateCall = "Left()" + or + index = nLeft and result = e.getRight() and partialPredicateCall = "Right()" + ) + ) + } + + private Element getImmediateChildOfSumAggregateSelection( + SumAggregateSelection e, int index, string partialPredicateCall + ) { + none() + } + + private Element getImmediateChildOfSuperCall(SuperCall e, int index, string partialPredicateCall) { + exists(int n, int nTransformation, int nActualParameter | + n = 0 and + nTransformation = n + 1 and + nActualParameter = nTransformation + e.getNumberOfActualParameters() and + ( + none() + or + index = n and result = e.getTransformation() and partialPredicateCall = "Transformation()" + or + result = e.getActualParameter(index - nTransformation) and + partialPredicateCall = "ActualParameter(" + (index - nTransformation).toString() + ")" + ) + ) + } + + private Element getImmediateChildOfTable(Table e, int index, string partialPredicateCall) { + exists( + int n, int nComments, int nRegion, int nBaseMethod, int nExtendGenericParameter, int nMethod, + int nModifierList, int nNestedClass, int nUsing, int nAttributes, int nField + | + n = 0 and + nComments = n + 1 and + nRegion = nComments + e.getNumberOfRegions() and + nBaseMethod = nRegion + e.getNumberOfBaseMethods() and + nExtendGenericParameter = nBaseMethod + e.getNumberOfExtendGenericParameters() and + nMethod = nExtendGenericParameter + e.getNumberOfMethods() and + nModifierList = nMethod + e.getNumberOfModifierLists() and + nNestedClass = nModifierList + e.getNumberOfNestedClasses() and + nUsing = nNestedClass + e.getNumberOfUsings() and + nAttributes = nUsing + 1 and + nField = nAttributes + e.getNumberOfFields() and + ( + none() + or + index = n and result = e.getComments() and partialPredicateCall = "Comments()" + or + result = e.getRegion(index - nComments) and + partialPredicateCall = "Region(" + (index - nComments).toString() + ")" + or + result = e.getBaseMethod(index - nRegion) and + partialPredicateCall = "BaseMethod(" + (index - nRegion).toString() + ")" + or + result = e.getExtendGenericParameter(index - nBaseMethod) and + partialPredicateCall = "ExtendGenericParameter(" + (index - nBaseMethod).toString() + ")" + or + result = e.getMethod(index - nExtendGenericParameter) and + partialPredicateCall = "Method(" + (index - nExtendGenericParameter).toString() + ")" + or + result = e.getModifierList(index - nMethod) and + partialPredicateCall = "ModifierList(" + (index - nMethod).toString() + ")" + or + result = e.getNestedClass(index - nModifierList) and + partialPredicateCall = "NestedClass(" + (index - nModifierList).toString() + ")" + or + result = e.getUsing(index - nNestedClass) and + partialPredicateCall = "Using(" + (index - nNestedClass).toString() + ")" + or + index = nUsing and result = e.getAttributes() and partialPredicateCall = "Attributes()" + or + result = e.getField(index - nAttributes) and + partialPredicateCall = "Field(" + (index - nAttributes).toString() + ")" + ) + ) + } + + private Element getImmediateChildOfTtsAbortStatement( + TtsAbortStatement e, int index, string partialPredicateCall + ) { + none() + } + + private Element getImmediateChildOfTtsBeginStatement( + TtsBeginStatement e, int index, string partialPredicateCall + ) { + none() + } + + private Element getImmediateChildOfTtsEndStatement( + TtsEndStatement e, int index, string partialPredicateCall + ) { + none() + } + + private Element getImmediateChildOfUnaryMinusExpression( + UnaryMinusExpression e, int index, string partialPredicateCall + ) { + exists(int n, int nTransformation, int nExpression | + n = 0 and + nTransformation = n + 1 and + nExpression = nTransformation + 1 and + ( + none() + or + index = n and result = e.getTransformation() and partialPredicateCall = "Transformation()" + or + index = nTransformation and + result = e.getExpression() and + partialPredicateCall = "Expression()" + ) + ) + } + + private Element getImmediateChildOfAssignPostDecrementStatement( + AssignPostDecrementStatement e, int index, string partialPredicateCall + ) { + exists(int n, int nField | + n = 0 and + nField = n + 1 and + ( + none() + or + index = n and result = e.getField() and partialPredicateCall = "Field()" + ) + ) + } + + private Element getImmediateChildOfAssignPostIncrementStatement( + AssignPostIncrementStatement e, int index, string partialPredicateCall + ) { + exists(int n, int nField | + n = 0 and + nField = n + 1 and + ( + none() + or + index = n and result = e.getField() and partialPredicateCall = "Field()" + ) + ) + } + + private Element getImmediateChildOfAssignPreDecrementStatement( + AssignPreDecrementStatement e, int index, string partialPredicateCall + ) { + exists(int n, int nField | + n = 0 and + nField = n + 1 and + ( + none() + or + index = n and result = e.getField() and partialPredicateCall = "Field()" + ) + ) + } + + private Element getImmediateChildOfAssignPreIncrementStatement( + AssignPreIncrementStatement e, int index, string partialPredicateCall + ) { + exists(int n, int nField | + n = 0 and + nField = n + 1 and + ( + none() + or + index = n and result = e.getField() and partialPredicateCall = "Field()" + ) + ) + } + + private Element getImmediateChildOfBooleanLiteralExpression( + BooleanLiteralExpression e, int index, string partialPredicateCall + ) { + exists(int n, int nTransformation | + n = 0 and + nTransformation = n + 1 and + ( + none() + or + index = n and result = e.getTransformation() and partialPredicateCall = "Transformation()" + ) + ) + } + + private Element getImmediateChildOfClass(Class e, int index, string partialPredicateCall) { + exists( + int n, int nComments, int nRegion, int nBaseMethod, int nExtendGenericParameter, int nMethod, + int nModifierList, int nNestedClass, int nUsing, int nAttributes, int nEnclosingType, + int nField + | + n = 0 and + nComments = n + 1 and + nRegion = nComments + e.getNumberOfRegions() and + nBaseMethod = nRegion + e.getNumberOfBaseMethods() and + nExtendGenericParameter = nBaseMethod + e.getNumberOfExtendGenericParameters() and + nMethod = nExtendGenericParameter + e.getNumberOfMethods() and + nModifierList = nMethod + e.getNumberOfModifierLists() and + nNestedClass = nModifierList + e.getNumberOfNestedClasses() and + nUsing = nNestedClass + e.getNumberOfUsings() and + nAttributes = nUsing + 1 and + nEnclosingType = nAttributes + 1 and + nField = nEnclosingType + e.getNumberOfFields() and + ( + none() + or + index = n and result = e.getComments() and partialPredicateCall = "Comments()" + or + result = e.getRegion(index - nComments) and + partialPredicateCall = "Region(" + (index - nComments).toString() + ")" + or + result = e.getBaseMethod(index - nRegion) and + partialPredicateCall = "BaseMethod(" + (index - nRegion).toString() + ")" + or + result = e.getExtendGenericParameter(index - nBaseMethod) and + partialPredicateCall = "ExtendGenericParameter(" + (index - nBaseMethod).toString() + ")" + or + result = e.getMethod(index - nExtendGenericParameter) and + partialPredicateCall = "Method(" + (index - nExtendGenericParameter).toString() + ")" + or + result = e.getModifierList(index - nMethod) and + partialPredicateCall = "ModifierList(" + (index - nMethod).toString() + ")" + or + result = e.getNestedClass(index - nModifierList) and + partialPredicateCall = "NestedClass(" + (index - nModifierList).toString() + ")" + or + result = e.getUsing(index - nNestedClass) and + partialPredicateCall = "Using(" + (index - nNestedClass).toString() + ")" + or + index = nUsing and result = e.getAttributes() and partialPredicateCall = "Attributes()" + or + index = nAttributes and + result = e.getEnclosingType() and + partialPredicateCall = "EnclosingType()" + or + result = e.getField(index - nEnclosingType) and + partialPredicateCall = "Field(" + (index - nEnclosingType).toString() + ")" + ) + ) + } + + private Element getImmediateChildOfDateLiteralExpression( + DateLiteralExpression e, int index, string partialPredicateCall + ) { + exists(int n, int nTransformation | + n = 0 and + nTransformation = n + 1 and + ( + none() + or + index = n and result = e.getTransformation() and partialPredicateCall = "Transformation()" + ) + ) + } + + private Element getImmediateChildOfDateTimeLiteralExpression( + DateTimeLiteralExpression e, int index, string partialPredicateCall + ) { + exists(int n, int nTransformation | + n = 0 and + nTransformation = n + 1 and + ( + none() + or + index = n and result = e.getTransformation() and partialPredicateCall = "Transformation()" + ) + ) + } + + private Element getImmediateChildOfEqualExpression( + EqualExpression e, int index, string partialPredicateCall + ) { + exists(int n, int nTransformation, int nLeft, int nRight | + n = 0 and + nTransformation = n + 1 and + nLeft = nTransformation + 1 and + nRight = nLeft + 1 and + ( + none() + or + index = n and result = e.getTransformation() and partialPredicateCall = "Transformation()" + or + index = nTransformation and result = e.getLeft() and partialPredicateCall = "Left()" + or + index = nLeft and result = e.getRight() and partialPredicateCall = "Right()" + ) + ) + } + + private Element getImmediateChildOfFieldDeclarationInternal( + FieldDeclarationInternal e, int index, string partialPredicateCall + ) { + exists( + int n, int nComments, int nRegion, int nArraySpecification, int nModifierList, int nType, + int nAttributes, int nInitialValue + | + n = 0 and + nComments = n + 1 and + nRegion = nComments + e.getNumberOfRegions() and + nArraySpecification = nRegion + 1 and + nModifierList = nArraySpecification + e.getNumberOfModifierLists() and + nType = nModifierList + 1 and + nAttributes = nType + 1 and + nInitialValue = nAttributes + 1 and + ( + none() + or + index = n and result = e.getComments() and partialPredicateCall = "Comments()" + or + result = e.getRegion(index - nComments) and + partialPredicateCall = "Region(" + (index - nComments).toString() + ")" + or + index = nRegion and + result = e.getArraySpecification() and + partialPredicateCall = "ArraySpecification()" + or + result = e.getModifierList(index - nArraySpecification) and + partialPredicateCall = "ModifierList(" + (index - nArraySpecification).toString() + ")" + or + index = nModifierList and result = e.getType() and partialPredicateCall = "Type()" + or + index = nType and result = e.getAttributes() and partialPredicateCall = "Attributes()" + or + index = nAttributes and + result = e.getInitialValue() and + partialPredicateCall = "InitialValue()" + ) + ) + } + + private Element getImmediateChildOfFormControl( + FormControl e, int index, string partialPredicateCall + ) { + exists( + int n, int nComments, int nRegion, int nBaseMethod, int nExtendGenericParameter, int nMethod, + int nModifierList, int nNestedClass, int nUsing, int nForm, int nChildControl, + int nParentControl + | + n = 0 and + nComments = n + 1 and + nRegion = nComments + e.getNumberOfRegions() and + nBaseMethod = nRegion + e.getNumberOfBaseMethods() and + nExtendGenericParameter = nBaseMethod + e.getNumberOfExtendGenericParameters() and + nMethod = nExtendGenericParameter + e.getNumberOfMethods() and + nModifierList = nMethod + e.getNumberOfModifierLists() and + nNestedClass = nModifierList + e.getNumberOfNestedClasses() and + nUsing = nNestedClass + e.getNumberOfUsings() and + nForm = nUsing + 1 and + nChildControl = nForm + e.getNumberOfChildControls() and + nParentControl = nChildControl + 1 and + ( + none() + or + index = n and result = e.getComments() and partialPredicateCall = "Comments()" + or + result = e.getRegion(index - nComments) and + partialPredicateCall = "Region(" + (index - nComments).toString() + ")" + or + result = e.getBaseMethod(index - nRegion) and + partialPredicateCall = "BaseMethod(" + (index - nRegion).toString() + ")" + or + result = e.getExtendGenericParameter(index - nBaseMethod) and + partialPredicateCall = "ExtendGenericParameter(" + (index - nBaseMethod).toString() + ")" + or + result = e.getMethod(index - nExtendGenericParameter) and + partialPredicateCall = "Method(" + (index - nExtendGenericParameter).toString() + ")" + or + result = e.getModifierList(index - nMethod) and + partialPredicateCall = "ModifierList(" + (index - nMethod).toString() + ")" + or + result = e.getNestedClass(index - nModifierList) and + partialPredicateCall = "NestedClass(" + (index - nModifierList).toString() + ")" + or + result = e.getUsing(index - nNestedClass) and + partialPredicateCall = "Using(" + (index - nNestedClass).toString() + ")" + or + index = nUsing and result = e.getForm() and partialPredicateCall = "Form()" + or + result = e.getChildControl(index - nForm) and + partialPredicateCall = "ChildControl(" + (index - nForm).toString() + ")" + or + index = nChildControl and + result = e.getParentControl() and + partialPredicateCall = "ParentControl()" + ) + ) + } + + private Element getImmediateChildOfFormDataField( + FormDataField e, int index, string partialPredicateCall + ) { + exists( + int n, int nComments, int nRegion, int nBaseMethod, int nExtendGenericParameter, int nMethod, + int nModifierList, int nNestedClass, int nUsing, int nForm, int nFormDataSource + | + n = 0 and + nComments = n + 1 and + nRegion = nComments + e.getNumberOfRegions() and + nBaseMethod = nRegion + e.getNumberOfBaseMethods() and + nExtendGenericParameter = nBaseMethod + e.getNumberOfExtendGenericParameters() and + nMethod = nExtendGenericParameter + e.getNumberOfMethods() and + nModifierList = nMethod + e.getNumberOfModifierLists() and + nNestedClass = nModifierList + e.getNumberOfNestedClasses() and + nUsing = nNestedClass + e.getNumberOfUsings() and + nForm = nUsing + 1 and + nFormDataSource = nForm + 1 and + ( + none() + or + index = n and result = e.getComments() and partialPredicateCall = "Comments()" + or + result = e.getRegion(index - nComments) and + partialPredicateCall = "Region(" + (index - nComments).toString() + ")" + or + result = e.getBaseMethod(index - nRegion) and + partialPredicateCall = "BaseMethod(" + (index - nRegion).toString() + ")" + or + result = e.getExtendGenericParameter(index - nBaseMethod) and + partialPredicateCall = "ExtendGenericParameter(" + (index - nBaseMethod).toString() + ")" + or + result = e.getMethod(index - nExtendGenericParameter) and + partialPredicateCall = "Method(" + (index - nExtendGenericParameter).toString() + ")" + or + result = e.getModifierList(index - nMethod) and + partialPredicateCall = "ModifierList(" + (index - nMethod).toString() + ")" + or + result = e.getNestedClass(index - nModifierList) and + partialPredicateCall = "NestedClass(" + (index - nModifierList).toString() + ")" + or + result = e.getUsing(index - nNestedClass) and + partialPredicateCall = "Using(" + (index - nNestedClass).toString() + ")" + or + index = nUsing and result = e.getForm() and partialPredicateCall = "Form()" + or + index = nForm and + result = e.getFormDataSource() and + partialPredicateCall = "FormDataSource()" + ) + ) + } + + private Element getImmediateChildOfFormDataSource( + FormDataSource e, int index, string partialPredicateCall + ) { + exists( + int n, int nComments, int nRegion, int nBaseMethod, int nExtendGenericParameter, int nMethod, + int nModifierList, int nNestedClass, int nUsing, int nForm, int nDataField, int nQuery + | + n = 0 and + nComments = n + 1 and + nRegion = nComments + e.getNumberOfRegions() and + nBaseMethod = nRegion + e.getNumberOfBaseMethods() and + nExtendGenericParameter = nBaseMethod + e.getNumberOfExtendGenericParameters() and + nMethod = nExtendGenericParameter + e.getNumberOfMethods() and + nModifierList = nMethod + e.getNumberOfModifierLists() and + nNestedClass = nModifierList + e.getNumberOfNestedClasses() and + nUsing = nNestedClass + e.getNumberOfUsings() and + nForm = nUsing + 1 and + nDataField = nForm + e.getNumberOfDataFields() and + nQuery = nDataField + 1 and + ( + none() + or + index = n and result = e.getComments() and partialPredicateCall = "Comments()" + or + result = e.getRegion(index - nComments) and + partialPredicateCall = "Region(" + (index - nComments).toString() + ")" + or + result = e.getBaseMethod(index - nRegion) and + partialPredicateCall = "BaseMethod(" + (index - nRegion).toString() + ")" + or + result = e.getExtendGenericParameter(index - nBaseMethod) and + partialPredicateCall = "ExtendGenericParameter(" + (index - nBaseMethod).toString() + ")" + or + result = e.getMethod(index - nExtendGenericParameter) and + partialPredicateCall = "Method(" + (index - nExtendGenericParameter).toString() + ")" + or + result = e.getModifierList(index - nMethod) and + partialPredicateCall = "ModifierList(" + (index - nMethod).toString() + ")" + or + result = e.getNestedClass(index - nModifierList) and + partialPredicateCall = "NestedClass(" + (index - nModifierList).toString() + ")" + or + result = e.getUsing(index - nNestedClass) and + partialPredicateCall = "Using(" + (index - nNestedClass).toString() + ")" + or + index = nUsing and result = e.getForm() and partialPredicateCall = "Form()" + or + result = e.getDataField(index - nForm) and + partialPredicateCall = "DataField(" + (index - nForm).toString() + ")" + or + index = nDataField and result = e.getQuery() and partialPredicateCall = "Query()" + ) + ) + } + + private Element getImmediateChildOfFormElementType( + FormElementType e, int index, string partialPredicateCall + ) { + exists(int n, int nTypeArgumentList | + n = 0 and + nTypeArgumentList = n + e.getNumberOfTypeArgumentLists() and + ( + none() + or + result = e.getTypeArgumentList(index - n) and + partialPredicateCall = "TypeArgumentList(" + (index - n).toString() + ")" + ) + ) + } + + private Element getImmediateChildOfFunctionCall( + FunctionCall e, int index, string partialPredicateCall + ) { + exists(int n, int nTransformation, int nActualParameter, int nTypeArgumentList | + n = 0 and + nTransformation = n + 1 and + nActualParameter = nTransformation + e.getNumberOfActualParameters() and + nTypeArgumentList = nActualParameter + e.getNumberOfTypeArgumentLists() and + ( + none() + or + index = n and result = e.getTransformation() and partialPredicateCall = "Transformation()" + or + result = e.getActualParameter(index - nTransformation) and + partialPredicateCall = "ActualParameter(" + (index - nTransformation).toString() + ")" + or + result = e.getTypeArgumentList(index - nActualParameter) and + partialPredicateCall = "TypeArgumentList(" + (index - nActualParameter).toString() + ")" + ) + ) + } + + private Element getImmediateChildOfFunctionDeclaration( + FunctionDeclaration e, int index, string partialPredicateCall + ) { + exists( + int n, int nComments, int nRegion, int nArraySpecification, int nModifierList, int nType, + int nDeclarationsAndStatement, int nLocal, int nParameter, int nStatement + | + n = 0 and + nComments = n + 1 and + nRegion = nComments + e.getNumberOfRegions() and + nArraySpecification = nRegion + 1 and + nModifierList = nArraySpecification + e.getNumberOfModifierLists() and + nType = nModifierList + 1 and + nDeclarationsAndStatement = nType + e.getNumberOfDeclarationsAndStatements() and + nLocal = nDeclarationsAndStatement + e.getNumberOfLocals() and + nParameter = nLocal + e.getNumberOfParameters() and + nStatement = nParameter + e.getNumberOfStatements() and + ( + none() + or + index = n and result = e.getComments() and partialPredicateCall = "Comments()" + or + result = e.getRegion(index - nComments) and + partialPredicateCall = "Region(" + (index - nComments).toString() + ")" + or + index = nRegion and + result = e.getArraySpecification() and + partialPredicateCall = "ArraySpecification()" + or + result = e.getModifierList(index - nArraySpecification) and + partialPredicateCall = "ModifierList(" + (index - nArraySpecification).toString() + ")" + or + index = nModifierList and result = e.getType() and partialPredicateCall = "Type()" + or + result = e.getDeclarationsAndStatement(index - nType) and + partialPredicateCall = "DeclarationsAndStatement(" + (index - nType).toString() + ")" + or + result = e.getLocal(index - nDeclarationsAndStatement) and + partialPredicateCall = "Local(" + (index - nDeclarationsAndStatement).toString() + ")" + or + result = e.getParameter(index - nLocal) and + partialPredicateCall = "Parameter(" + (index - nLocal).toString() + ")" + or + result = e.getStatement(index - nParameter) and + partialPredicateCall = "Statement(" + (index - nParameter).toString() + ")" + ) + ) + } + + private Element getImmediateChildOfGreaterThanExpression( + GreaterThanExpression e, int index, string partialPredicateCall + ) { + exists(int n, int nTransformation, int nLeft, int nRight | + n = 0 and + nTransformation = n + 1 and + nLeft = nTransformation + 1 and + nRight = nLeft + 1 and + ( + none() + or + index = n and result = e.getTransformation() and partialPredicateCall = "Transformation()" + or + index = nTransformation and result = e.getLeft() and partialPredicateCall = "Left()" + or + index = nLeft and result = e.getRight() and partialPredicateCall = "Right()" + ) + ) + } + + private Element getImmediateChildOfGreaterThanOrEqualExpression( + GreaterThanOrEqualExpression e, int index, string partialPredicateCall + ) { + exists(int n, int nTransformation, int nLeft, int nRight | + n = 0 and + nTransformation = n + 1 and + nLeft = nTransformation + 1 and + nRight = nLeft + 1 and + ( + none() + or + index = n and result = e.getTransformation() and partialPredicateCall = "Transformation()" + or + index = nTransformation and result = e.getLeft() and partialPredicateCall = "Left()" + or + index = nLeft and result = e.getRight() and partialPredicateCall = "Right()" + ) + ) + } + + private Element getImmediateChildOfInt64LiteralExpression( + Int64LiteralExpression e, int index, string partialPredicateCall + ) { + exists(int n, int nTransformation | + n = 0 and + nTransformation = n + 1 and + ( + none() + or + index = n and result = e.getTransformation() and partialPredicateCall = "Transformation()" + ) + ) + } + + private Element getImmediateChildOfIntLiteralExpression( + IntLiteralExpression e, int index, string partialPredicateCall + ) { + exists(int n, int nTransformation | + n = 0 and + nTransformation = n + 1 and + ( + none() + or + index = n and result = e.getTransformation() and partialPredicateCall = "Transformation()" + ) + ) + } + + private Element getImmediateChildOfInterface(Interface e, int index, string partialPredicateCall) { + exists( + int n, int nComments, int nRegion, int nBaseMethod, int nExtendGenericParameter, int nMethod, + int nModifierList, int nNestedClass, int nUsing, int nAttributes, int nEnclosingType + | + n = 0 and + nComments = n + 1 and + nRegion = nComments + e.getNumberOfRegions() and + nBaseMethod = nRegion + e.getNumberOfBaseMethods() and + nExtendGenericParameter = nBaseMethod + e.getNumberOfExtendGenericParameters() and + nMethod = nExtendGenericParameter + e.getNumberOfMethods() and + nModifierList = nMethod + e.getNumberOfModifierLists() and + nNestedClass = nModifierList + e.getNumberOfNestedClasses() and + nUsing = nNestedClass + e.getNumberOfUsings() and + nAttributes = nUsing + 1 and + nEnclosingType = nAttributes + 1 and + ( + none() + or + index = n and result = e.getComments() and partialPredicateCall = "Comments()" + or + result = e.getRegion(index - nComments) and + partialPredicateCall = "Region(" + (index - nComments).toString() + ")" + or + result = e.getBaseMethod(index - nRegion) and + partialPredicateCall = "BaseMethod(" + (index - nRegion).toString() + ")" + or + result = e.getExtendGenericParameter(index - nBaseMethod) and + partialPredicateCall = "ExtendGenericParameter(" + (index - nBaseMethod).toString() + ")" + or + result = e.getMethod(index - nExtendGenericParameter) and + partialPredicateCall = "Method(" + (index - nExtendGenericParameter).toString() + ")" + or + result = e.getModifierList(index - nMethod) and + partialPredicateCall = "ModifierList(" + (index - nMethod).toString() + ")" + or + result = e.getNestedClass(index - nModifierList) and + partialPredicateCall = "NestedClass(" + (index - nModifierList).toString() + ")" + or + result = e.getUsing(index - nNestedClass) and + partialPredicateCall = "Using(" + (index - nNestedClass).toString() + ")" + or + index = nUsing and result = e.getAttributes() and partialPredicateCall = "Attributes()" + or + index = nAttributes and + result = e.getEnclosingType() and + partialPredicateCall = "EnclosingType()" + ) + ) + } + + private Element getImmediateChildOfLessThanExpression( + LessThanExpression e, int index, string partialPredicateCall + ) { + exists(int n, int nTransformation, int nLeft, int nRight | + n = 0 and + nTransformation = n + 1 and + nLeft = nTransformation + 1 and + nRight = nLeft + 1 and + ( + none() + or + index = n and result = e.getTransformation() and partialPredicateCall = "Transformation()" + or + index = nTransformation and result = e.getLeft() and partialPredicateCall = "Left()" + or + index = nLeft and result = e.getRight() and partialPredicateCall = "Right()" + ) + ) + } + + private Element getImmediateChildOfLessThanOrEqualExpression( + LessThanOrEqualExpression e, int index, string partialPredicateCall + ) { + exists(int n, int nTransformation, int nLeft, int nRight | + n = 0 and + nTransformation = n + 1 and + nLeft = nTransformation + 1 and + nRight = nLeft + 1 and + ( + none() + or + index = n and result = e.getTransformation() and partialPredicateCall = "Transformation()" + or + index = nTransformation and result = e.getLeft() and partialPredicateCall = "Left()" + or + index = nLeft and result = e.getRight() and partialPredicateCall = "Right()" + ) + ) + } + + private Element getImmediateChildOfLikeExpression( + LikeExpression e, int index, string partialPredicateCall + ) { + exists(int n, int nTransformation, int nLeft, int nRight | + n = 0 and + nTransformation = n + 1 and + nLeft = nTransformation + 1 and + nRight = nLeft + 1 and + ( + none() + or + index = n and result = e.getTransformation() and partialPredicateCall = "Transformation()" + or + index = nTransformation and result = e.getLeft() and partialPredicateCall = "Left()" + or + index = nLeft and result = e.getRight() and partialPredicateCall = "Right()" + ) + ) + } + + private Element getImmediateChildOfNamedTypeInternal( + NamedTypeInternal e, int index, string partialPredicateCall + ) { + exists(int n, int nTypeArgumentList | + n = 0 and + nTypeArgumentList = n + e.getNumberOfTypeArgumentLists() and + ( + none() + or + result = e.getTypeArgumentList(index - n) and + partialPredicateCall = "TypeArgumentList(" + (index - n).toString() + ")" + ) + ) + } + + private Element getImmediateChildOfNewClrCall(NewClrCall e, int index, string partialPredicateCall) { + exists(int n, int nTransformation, int nActualParameter, int nTypeArgumentList | + n = 0 and + nTransformation = n + 1 and + nActualParameter = nTransformation + e.getNumberOfActualParameters() and + nTypeArgumentList = nActualParameter + e.getNumberOfTypeArgumentLists() and + ( + none() + or + index = n and result = e.getTransformation() and partialPredicateCall = "Transformation()" + or + result = e.getActualParameter(index - nTransformation) and + partialPredicateCall = "ActualParameter(" + (index - nTransformation).toString() + ")" + or + result = e.getTypeArgumentList(index - nActualParameter) and + partialPredicateCall = "TypeArgumentList(" + (index - nActualParameter).toString() + ")" + ) + ) + } + + private Element getImmediateChildOfNotEqualExpression( + NotEqualExpression e, int index, string partialPredicateCall + ) { + exists(int n, int nTransformation, int nLeft, int nRight | + n = 0 and + nTransformation = n + 1 and + nLeft = nTransformation + 1 and + nRight = nLeft + 1 and + ( + none() + or + index = n and result = e.getTransformation() and partialPredicateCall = "Transformation()" + or + index = nTransformation and result = e.getLeft() and partialPredicateCall = "Left()" + or + index = nLeft and result = e.getRight() and partialPredicateCall = "Right()" + ) + ) + } + + private Element getImmediateChildOfQualifiedCall( + QualifiedCall e, int index, string partialPredicateCall + ) { + exists(int n, int nTransformation, int nActualParameter, int nTypeArgumentList, int nQualifier | + n = 0 and + nTransformation = n + 1 and + nActualParameter = nTransformation + e.getNumberOfActualParameters() and + nTypeArgumentList = nActualParameter + e.getNumberOfTypeArgumentLists() and + nQualifier = nTypeArgumentList + 1 and + ( + none() + or + index = n and result = e.getTransformation() and partialPredicateCall = "Transformation()" + or + result = e.getActualParameter(index - nTransformation) and + partialPredicateCall = "ActualParameter(" + (index - nTransformation).toString() + ")" + or + result = e.getTypeArgumentList(index - nActualParameter) and + partialPredicateCall = "TypeArgumentList(" + (index - nActualParameter).toString() + ")" + or + index = nTypeArgumentList and + result = e.getQualifier() and + partialPredicateCall = "Qualifier()" + ) + ) + } + + private Element getImmediateChildOfQualifiedStaticCall( + QualifiedStaticCall e, int index, string partialPredicateCall + ) { + exists( + int n, int nTransformation, int nActualParameter, int nTypeArgumentList, + int nClassTypeArgumentList, int nQualifier + | + n = 0 and + nTransformation = n + 1 and + nActualParameter = nTransformation + e.getNumberOfActualParameters() and + nTypeArgumentList = nActualParameter + e.getNumberOfTypeArgumentLists() and + nClassTypeArgumentList = nTypeArgumentList + e.getNumberOfClassTypeArgumentLists() and + nQualifier = nClassTypeArgumentList + 1 and + ( + none() + or + index = n and result = e.getTransformation() and partialPredicateCall = "Transformation()" + or + result = e.getActualParameter(index - nTransformation) and + partialPredicateCall = "ActualParameter(" + (index - nTransformation).toString() + ")" + or + result = e.getTypeArgumentList(index - nActualParameter) and + partialPredicateCall = "TypeArgumentList(" + (index - nActualParameter).toString() + ")" + or + result = e.getClassTypeArgumentList(index - nTypeArgumentList) and + partialPredicateCall = + "ClassTypeArgumentList(" + (index - nTypeArgumentList).toString() + ")" + or + index = nClassTypeArgumentList and + result = e.getQualifier() and + partialPredicateCall = "Qualifier()" + ) + ) + } + + private Element getImmediateChildOfRealLiteralExpression( + RealLiteralExpression e, int index, string partialPredicateCall + ) { + exists(int n, int nTransformation | + n = 0 and + nTransformation = n + 1 and + ( + none() + or + index = n and result = e.getTransformation() and partialPredicateCall = "Transformation()" + ) + ) + } + + private Element getImmediateChildOfStaticMethodCall( + StaticMethodCall e, int index, string partialPredicateCall + ) { + exists( + int n, int nTransformation, int nActualParameter, int nTypeArgumentList, + int nClassTypeArgumentList + | + n = 0 and + nTransformation = n + 1 and + nActualParameter = nTransformation + e.getNumberOfActualParameters() and + nTypeArgumentList = nActualParameter + e.getNumberOfTypeArgumentLists() and + nClassTypeArgumentList = nTypeArgumentList + e.getNumberOfClassTypeArgumentLists() and + ( + none() + or + index = n and result = e.getTransformation() and partialPredicateCall = "Transformation()" + or + result = e.getActualParameter(index - nTransformation) and + partialPredicateCall = "ActualParameter(" + (index - nTransformation).toString() + ")" + or + result = e.getTypeArgumentList(index - nActualParameter) and + partialPredicateCall = "TypeArgumentList(" + (index - nActualParameter).toString() + ")" + or + result = e.getClassTypeArgumentList(index - nTypeArgumentList) and + partialPredicateCall = + "ClassTypeArgumentList(" + (index - nTypeArgumentList).toString() + ")" + ) + ) + } + + private Element getImmediateChildOfStringLiteralExpression( + StringLiteralExpression e, int index, string partialPredicateCall + ) { + exists(int n, int nTransformation | + n = 0 and + nTransformation = n + 1 and + ( + none() + or + index = n and result = e.getTransformation() and partialPredicateCall = "Transformation()" + ) + ) + } + + private Element getImmediateChildOfTableFieldDeclaration( + TableFieldDeclaration e, int index, string partialPredicateCall + ) { + exists( + int n, int nComments, int nRegion, int nArraySpecification, int nModifierList, int nType, + int nAttributes, int nInitialValue + | + n = 0 and + nComments = n + 1 and + nRegion = nComments + e.getNumberOfRegions() and + nArraySpecification = nRegion + 1 and + nModifierList = nArraySpecification + e.getNumberOfModifierLists() and + nType = nModifierList + 1 and + nAttributes = nType + 1 and + nInitialValue = nAttributes + 1 and + ( + none() + or + index = n and result = e.getComments() and partialPredicateCall = "Comments()" + or + result = e.getRegion(index - nComments) and + partialPredicateCall = "Region(" + (index - nComments).toString() + ")" + or + index = nRegion and + result = e.getArraySpecification() and + partialPredicateCall = "ArraySpecification()" + or + result = e.getModifierList(index - nArraySpecification) and + partialPredicateCall = "ModifierList(" + (index - nArraySpecification).toString() + ")" + or + index = nModifierList and result = e.getType() and partialPredicateCall = "Type()" + or + index = nType and result = e.getAttributes() and partialPredicateCall = "Attributes()" + or + index = nAttributes and + result = e.getInitialValue() and + partialPredicateCall = "InitialValue()" + ) + ) + } + + private Element getImmediateChildOfAssignDecrementStatement( + AssignDecrementStatement e, int index, string partialPredicateCall + ) { + exists(int n, int nField, int nExpression | + n = 0 and + nField = n + 1 and + nExpression = nField + 1 and + ( + none() + or + index = n and result = e.getField() and partialPredicateCall = "Field()" + or + index = nField and result = e.getExpression() and partialPredicateCall = "Expression()" + ) + ) + } + + private Element getImmediateChildOfAssignDivideStatement( + AssignDivideStatement e, int index, string partialPredicateCall + ) { + exists(int n, int nField, int nExpression | + n = 0 and + nField = n + 1 and + nExpression = nField + 1 and + ( + none() + or + index = n and result = e.getField() and partialPredicateCall = "Field()" + or + index = nField and result = e.getExpression() and partialPredicateCall = "Expression()" + ) + ) + } + + private Element getImmediateChildOfAssignEqualStatement( + AssignEqualStatement e, int index, string partialPredicateCall + ) { + exists(int n, int nField, int nExpression | + n = 0 and + nField = n + 1 and + nExpression = nField + 1 and + ( + none() + or + index = n and result = e.getField() and partialPredicateCall = "Field()" + or + index = nField and result = e.getExpression() and partialPredicateCall = "Expression()" + ) + ) + } + + private Element getImmediateChildOfAssignIncrementStatement( + AssignIncrementStatement e, int index, string partialPredicateCall + ) { + exists(int n, int nField, int nExpression | + n = 0 and + nField = n + 1 and + nExpression = nField + 1 and + ( + none() + or + index = n and result = e.getField() and partialPredicateCall = "Field()" + or + index = nField and result = e.getExpression() and partialPredicateCall = "Expression()" + ) + ) + } + + private Element getImmediateChildOfAssignMultiplyStatement( + AssignMultiplyStatement e, int index, string partialPredicateCall + ) { + exists(int n, int nField, int nExpression | + n = 0 and + nField = n + 1 and + nExpression = nField + 1 and + ( + none() + or + index = n and result = e.getField() and partialPredicateCall = "Field()" + or + index = nField and result = e.getExpression() and partialPredicateCall = "Expression()" + ) + ) + } + + private Element getImmediateChildOfAssignmentEventHandlerInstance( + AssignmentEventHandlerInstance e, int index, string partialPredicateCall + ) { + exists(int n, int nField, int nQualifierPart | + n = 0 and + nField = n + 1 and + nQualifierPart = nField + 1 and + ( + none() + or + index = n and result = e.getField() and partialPredicateCall = "Field()" + or + index = nField and + result = e.getQualifierPart() and + partialPredicateCall = "QualifierPart()" + ) + ) + } + + private Element getImmediateChildOfParameterDeclaration( + ParameterDeclaration e, int index, string partialPredicateCall + ) { + exists( + int n, int nComments, int nRegion, int nArraySpecification, int nModifierList, int nType, + int nInitialValue + | + n = 0 and + nComments = n + 1 and + nRegion = nComments + e.getNumberOfRegions() and + nArraySpecification = nRegion + 1 and + nModifierList = nArraySpecification + e.getNumberOfModifierLists() and + nType = nModifierList + 1 and + nInitialValue = nType + 1 and + ( + none() + or + index = n and result = e.getComments() and partialPredicateCall = "Comments()" + or + result = e.getRegion(index - nComments) and + partialPredicateCall = "Region(" + (index - nComments).toString() + ")" + or + index = nRegion and + result = e.getArraySpecification() and + partialPredicateCall = "ArraySpecification()" + or + result = e.getModifierList(index - nArraySpecification) and + partialPredicateCall = "ModifierList(" + (index - nArraySpecification).toString() + ")" + or + index = nModifierList and result = e.getType() and partialPredicateCall = "Type()" + or + index = nType and result = e.getInitialValue() and partialPredicateCall = "InitialValue()" + ) + ) + } + + private Element getImmediateChildOfVariableDeclarationInternal( + VariableDeclarationInternal e, int index, string partialPredicateCall + ) { + exists( + int n, int nComments, int nRegion, int nArraySpecification, int nModifierList, int nType, + int nInitialValue + | + n = 0 and + nComments = n + 1 and + nRegion = nComments + e.getNumberOfRegions() and + nArraySpecification = nRegion + 1 and + nModifierList = nArraySpecification + e.getNumberOfModifierLists() and + nType = nModifierList + 1 and + nInitialValue = nType + 1 and + ( + none() + or + index = n and result = e.getComments() and partialPredicateCall = "Comments()" + or + result = e.getRegion(index - nComments) and + partialPredicateCall = "Region(" + (index - nComments).toString() + ")" + or + index = nRegion and + result = e.getArraySpecification() and + partialPredicateCall = "ArraySpecification()" + or + result = e.getModifierList(index - nArraySpecification) and + partialPredicateCall = "ModifierList(" + (index - nArraySpecification).toString() + ")" + or + index = nModifierList and result = e.getType() and partialPredicateCall = "Type()" + or + index = nType and result = e.getInitialValue() and partialPredicateCall = "InitialValue()" + ) + ) + } + + private Element getImmediateChildOfAssignmentEventHandlerClr( + AssignmentEventHandlerClr e, int index, string partialPredicateCall + ) { + exists(int n, int nField | + n = 0 and + nField = n + 1 and + ( + none() + or + index = n and result = e.getField() and partialPredicateCall = "Field()" + ) + ) + } + + private Element getImmediateChildOfAssignmentEventHandlerStaticInternal( + AssignmentEventHandlerStaticInternal e, int index, string partialPredicateCall + ) { + exists(int n, int nField | + n = 0 and + nField = n + 1 and + ( + none() + or + index = n and result = e.getField() and partialPredicateCall = "Field()" + ) + ) + } + + cached + Element getImmediateChild(Element e, int index, string partialAccessor) { + // why does this look more complicated than it should? + // * none() simplifies generation, as we can append `or ...` without a special case for the first item + none() + or + result = getImmediateChildOfFile(e, index, partialAccessor) + or + result = getImmediateChildOfLocation(e, index, partialAccessor) + or + result = getImmediateChildOfComment(e, index, partialAccessor) + or + result = getImmediateChildOfArraySpecification(e, index, partialAccessor) + or + result = getImmediateChildOfAttribute(e, index, partialAccessor) + or + result = getImmediateChildOfAttributeExpression(e, index, partialAccessor) + or + result = getImmediateChildOfAttributeList(e, index, partialAccessor) + or + result = getImmediateChildOfAttributeNamedParameterEntry(e, index, partialAccessor) + or + result = getImmediateChildOfClassAccessModifier(e, index, partialAccessor) + or + result = getImmediateChildOfCompilationUnitRegionEntry(e, index, partialAccessor) + or + result = getImmediateChildOfEvaluationActualParameterEntry(e, index, partialAccessor) + or + result = getImmediateChildOfFieldAssignment(e, index, partialAccessor) + or + result = getImmediateChildOfInsertFieldSpecification(e, index, partialAccessor) + or + result = getImmediateChildOfJoinSpecification(e, index, partialAccessor) + or + result = getImmediateChildOfModelElementUsingEntry(e, index, partialAccessor) + or + result = getImmediateChildOfModifier(e, index, partialAccessor) + or + result = getImmediateChildOfQuery(e, index, partialAccessor) + or + result = getImmediateChildOfQueryDataSource(e, index, partialAccessor) + or + result = getImmediateChildOfQueryDataSourceHaving(e, index, partialAccessor) + or + result = getImmediateChildOfQueryDataSourceRange(e, index, partialAccessor) + or + result = getImmediateChildOfQueryDataSourceRelation(e, index, partialAccessor) + or + result = getImmediateChildOfSwitchCase(e, index, partialAccessor) + or + result = getImmediateChildOfSwitchStatementCaseEntry(e, index, partialAccessor) + or + result = getImmediateChildOfTryStatementCatchEntry(e, index, partialAccessor) + or + result = getImmediateChildOfUnspecifiedElement(e, index, partialAccessor) + or + result = getImmediateChildOfAllFieldsSelection(e, index, partialAccessor) + or + result = getImmediateChildOfAnyType(e, index, partialAccessor) + or + result = getImmediateChildOfBooleanType(e, index, partialAccessor) + or + result = getImmediateChildOfBreakStatement(e, index, partialAccessor) + or + result = getImmediateChildOfBreakpointStatement(e, index, partialAccessor) + or + result = getImmediateChildOfCaseDefault(e, index, partialAccessor) + or + result = getImmediateChildOfCaseValues(e, index, partialAccessor) + or + result = getImmediateChildOfCatchAllValues(e, index, partialAccessor) + or + result = getImmediateChildOfCatchExpression(e, index, partialAccessor) + or + result = getImmediateChildOfCatchUpdateConflict(e, index, partialAccessor) + or + result = getImmediateChildOfCompoundStatement(e, index, partialAccessor) + or + result = getImmediateChildOfConditionalExpression(e, index, partialAccessor) + or + result = getImmediateChildOfContainerAttributeLiteral(e, index, partialAccessor) + or + result = getImmediateChildOfContainerType(e, index, partialAccessor) + or + result = getImmediateChildOfContinueStatement(e, index, partialAccessor) + or + result = getImmediateChildOfCrossCompanyAll(e, index, partialAccessor) + or + result = getImmediateChildOfCrossCompanyContainer(e, index, partialAccessor) + or + result = getImmediateChildOfDateTimeType(e, index, partialAccessor) + or + result = getImmediateChildOfDateType(e, index, partialAccessor) + or + result = getImmediateChildOfDblType(e, index, partialAccessor) + or + result = getImmediateChildOfDeleteStatement(e, index, partialAccessor) + or + result = getImmediateChildOfDoWhileStatement(e, index, partialAccessor) + or + result = getImmediateChildOfEmptyExpression(e, index, partialAccessor) + or + result = getImmediateChildOfEmptyStatement(e, index, partialAccessor) + or + result = getImmediateChildOfEnumAttributeLiteral(e, index, partialAccessor) + or + result = getImmediateChildOfEnumerationType(e, index, partialAccessor) + or + result = getImmediateChildOfExplicitSelection(e, index, partialAccessor) + or + result = getImmediateChildOfExpressionCompilationUnit(e, index, partialAccessor) + or + result = getImmediateChildOfExpressionQualifier(e, index, partialAccessor) + or + result = getImmediateChildOfExpressionStatement(e, index, partialAccessor) + or + result = getImmediateChildOfFieldSelection(e, index, partialAccessor) + or + result = getImmediateChildOfFindStatement(e, index, partialAccessor) + or + result = getImmediateChildOfFlushStatement(e, index, partialAccessor) + or + result = getImmediateChildOfForDeclarationAssign(e, index, partialAccessor) + or + result = getImmediateChildOfForFieldPostDecrement(e, index, partialAccessor) + or + result = getImmediateChildOfForFieldPostIncrement(e, index, partialAccessor) + or + result = getImmediateChildOfForFieldPreDecrement(e, index, partialAccessor) + or + result = getImmediateChildOfForFieldPreIncrement(e, index, partialAccessor) + or + result = getImmediateChildOfForStatement(e, index, partialAccessor) + or + result = getImmediateChildOfGlobalOrderElement(e, index, partialAccessor) + or + result = getImmediateChildOfGuidType(e, index, partialAccessor) + or + result = getImmediateChildOfIfStatement(e, index, partialAccessor) + or + result = getImmediateChildOfIfThenElseStatement(e, index, partialAccessor) + or + result = getImmediateChildOfImplicitSelection(e, index, partialAccessor) + or + result = getImmediateChildOfInsertStatement(e, index, partialAccessor) + or + result = getImmediateChildOfInt64Type(e, index, partialAccessor) + or + result = getImmediateChildOfIntType(e, index, partialAccessor) + or + result = getImmediateChildOfIntrinsic(e, index, partialAccessor) + or + result = getImmediateChildOfIntrinsicAttributeLiteral(e, index, partialAccessor) + or + result = getImmediateChildOfLocalDeclarationsStatement(e, index, partialAccessor) + or + result = getImmediateChildOfMoveCursorStatement(e, index, partialAccessor) + or + result = getImmediateChildOfNamedFieldReference(e, index, partialAccessor) + or + result = getImmediateChildOfNewClrArrayExpression(e, index, partialAccessor) + or + result = getImmediateChildOfNumberedFieldReference(e, index, partialAccessor) + or + result = getImmediateChildOfPlaceholder(e, index, partialAccessor) + or + result = getImmediateChildOfPrintStatement(e, index, partialAccessor) + or + result = getImmediateChildOfProvidedType(e, index, partialAccessor) + or + result = getImmediateChildOfQualifiedField(e, index, partialAccessor) + or + result = getImmediateChildOfQualifiedInstanceName(e, index, partialAccessor) + or + result = getImmediateChildOfQualifiedNumberedField(e, index, partialAccessor) + or + result = getImmediateChildOfQualifiedStaticField(e, index, partialAccessor) + or + result = getImmediateChildOfRetryStatement(e, index, partialAccessor) + or + result = getImmediateChildOfReturnStatement(e, index, partialAccessor) + or + result = getImmediateChildOfSearchStatement(e, index, partialAccessor) + or + result = getImmediateChildOfSimpleField(e, index, partialAccessor) + or + result = getImmediateChildOfSimpleInstanceName(e, index, partialAccessor) + or + result = getImmediateChildOfSimpleOrderElement(e, index, partialAccessor) + or + result = getImmediateChildOfStaticField(e, index, partialAccessor) + or + result = getImmediateChildOfSwitchStatement(e, index, partialAccessor) + or + result = getImmediateChildOfTableLookupExpression(e, index, partialAccessor) + or + result = getImmediateChildOfThrowStatement(e, index, partialAccessor) + or + result = getImmediateChildOfTryStatement(e, index, partialAccessor) + or + result = getImmediateChildOfUncheckedStatement(e, index, partialAccessor) + or + result = getImmediateChildOfUpdateStatement(e, index, partialAccessor) + or + result = getImmediateChildOfUsingStatement(e, index, partialAccessor) + or + result = getImmediateChildOfValidTimeStateDate(e, index, partialAccessor) + or + result = getImmediateChildOfValidTimeStateRange(e, index, partialAccessor) + or + result = getImmediateChildOfVarType(e, index, partialAccessor) + or + result = getImmediateChildOfVoidType(e, index, partialAccessor) + or + result = getImmediateChildOfWhileStatement(e, index, partialAccessor) + or + result = getImmediateChildOfXppTypeCompilationUnit(e, index, partialAccessor) + or + result = getImmediateChildOfAddExpression(e, index, partialAccessor) + or + result = getImmediateChildOfAndExpression(e, index, partialAccessor) + or + result = getImmediateChildOfAsClrExpression(e, index, partialAccessor) + or + result = getImmediateChildOfAsExpression(e, index, partialAccessor) + or + result = getImmediateChildOfAssignMultipleFieldStatement(e, index, partialAccessor) + or + result = getImmediateChildOfAvgAggregateSelection(e, index, partialAccessor) + or + result = getImmediateChildOfBooleanAttributeLiteral(e, index, partialAccessor) + or + result = getImmediateChildOfChangeCompanyStatement(e, index, partialAccessor) + or + result = getImmediateChildOfClrEnumerationLiteralExpression(e, index, partialAccessor) + or + result = getImmediateChildOfClrType(e, index, partialAccessor) + or + result = getImmediateChildOfContainerLiteralExpression(e, index, partialAccessor) + or + result = getImmediateChildOfCountAggregateSelection(e, index, partialAccessor) + or + result = getImmediateChildOfDateAttributeLiteral(e, index, partialAccessor) + or + result = getImmediateChildOfDateTimeAttributeLiteral(e, index, partialAccessor) + or + result = getImmediateChildOfDblAttributeLiteral(e, index, partialAccessor) + or + result = getImmediateChildOfDelegate(e, index, partialAccessor) + or + result = getImmediateChildOfDivideExpression(e, index, partialAccessor) + or + result = getImmediateChildOfEnumerationLiteralExpression(e, index, partialAccessor) + or + result = getImmediateChildOfFieldExpressionInternal(e, index, partialAccessor) + or + result = getImmediateChildOfForFieldAssign(e, index, partialAccessor) + or + result = getImmediateChildOfForFieldDecrementAssign(e, index, partialAccessor) + or + result = getImmediateChildOfForFieldIncrementAssign(e, index, partialAccessor) + or + result = getImmediateChildOfFormModelElement(e, index, partialAccessor) + or + result = getImmediateChildOfGuidAttributeLiteral(e, index, partialAccessor) + or + result = getImmediateChildOfInExpression(e, index, partialAccessor) + or + result = getImmediateChildOfInt64AttributeLiteral(e, index, partialAccessor) + or + result = getImmediateChildOfIntAttributeLiteral(e, index, partialAccessor) + or + result = getImmediateChildOfIntegerDivideExpression(e, index, partialAccessor) + or + result = getImmediateChildOfIsClrExpression(e, index, partialAccessor) + or + result = getImmediateChildOfIsExpression(e, index, partialAccessor) + or + result = getImmediateChildOfMaxAggregateSelection(e, index, partialAccessor) + or + result = getImmediateChildOfMethod(e, index, partialAccessor) + or + result = getImmediateChildOfMinAggregateSelection(e, index, partialAccessor) + or + result = getImmediateChildOfModExpression(e, index, partialAccessor) + or + result = getImmediateChildOfMultiplyExpression(e, index, partialAccessor) + or + result = getImmediateChildOfNewCall(e, index, partialAccessor) + or + result = getImmediateChildOfNextExpression(e, index, partialAccessor) + or + result = getImmediateChildOfNotExpression(e, index, partialAccessor) + or + result = getImmediateChildOfNullLiteralExpression(e, index, partialAccessor) + or + result = getImmediateChildOfOrExpression(e, index, partialAccessor) + or + result = getImmediateChildOfPhysicalAndExpression(e, index, partialAccessor) + or + result = getImmediateChildOfPhysicalNotExpression(e, index, partialAccessor) + or + result = getImmediateChildOfPhysicalOrExpression(e, index, partialAccessor) + or + result = getImmediateChildOfPhysicalXorExpression(e, index, partialAccessor) + or + result = getImmediateChildOfProvidedTypeStaticCall(e, index, partialAccessor) + or + result = getImmediateChildOfQualifiedStaticFieldExpression(e, index, partialAccessor) + or + result = getImmediateChildOfQueryModelElement(e, index, partialAccessor) + or + result = getImmediateChildOfShiftLeftExpression(e, index, partialAccessor) + or + result = getImmediateChildOfShiftRightExpression(e, index, partialAccessor) + or + result = getImmediateChildOfSimpleQualifierInternal(e, index, partialAccessor) + or + result = getImmediateChildOfStaticQualifier(e, index, partialAccessor) + or + result = getImmediateChildOfStringAttributeLiteral(e, index, partialAccessor) + or + result = getImmediateChildOfStringLengthType(e, index, partialAccessor) + or + result = getImmediateChildOfStringTypeInternal(e, index, partialAccessor) + or + result = getImmediateChildOfSubtractExpression(e, index, partialAccessor) + or + result = getImmediateChildOfSumAggregateSelection(e, index, partialAccessor) + or + result = getImmediateChildOfSuperCall(e, index, partialAccessor) + or + result = getImmediateChildOfTable(e, index, partialAccessor) + or + result = getImmediateChildOfTtsAbortStatement(e, index, partialAccessor) + or + result = getImmediateChildOfTtsBeginStatement(e, index, partialAccessor) + or + result = getImmediateChildOfTtsEndStatement(e, index, partialAccessor) + or + result = getImmediateChildOfUnaryMinusExpression(e, index, partialAccessor) + or + result = getImmediateChildOfAssignPostDecrementStatement(e, index, partialAccessor) + or + result = getImmediateChildOfAssignPostIncrementStatement(e, index, partialAccessor) + or + result = getImmediateChildOfAssignPreDecrementStatement(e, index, partialAccessor) + or + result = getImmediateChildOfAssignPreIncrementStatement(e, index, partialAccessor) + or + result = getImmediateChildOfBooleanLiteralExpression(e, index, partialAccessor) + or + result = getImmediateChildOfClass(e, index, partialAccessor) + or + result = getImmediateChildOfDateLiteralExpression(e, index, partialAccessor) + or + result = getImmediateChildOfDateTimeLiteralExpression(e, index, partialAccessor) + or + result = getImmediateChildOfEqualExpression(e, index, partialAccessor) + or + result = getImmediateChildOfFieldDeclarationInternal(e, index, partialAccessor) + or + result = getImmediateChildOfFormControl(e, index, partialAccessor) + or + result = getImmediateChildOfFormDataField(e, index, partialAccessor) + or + result = getImmediateChildOfFormDataSource(e, index, partialAccessor) + or + result = getImmediateChildOfFormElementType(e, index, partialAccessor) + or + result = getImmediateChildOfFunctionCall(e, index, partialAccessor) + or + result = getImmediateChildOfFunctionDeclaration(e, index, partialAccessor) + or + result = getImmediateChildOfGreaterThanExpression(e, index, partialAccessor) + or + result = getImmediateChildOfGreaterThanOrEqualExpression(e, index, partialAccessor) + or + result = getImmediateChildOfInt64LiteralExpression(e, index, partialAccessor) + or + result = getImmediateChildOfIntLiteralExpression(e, index, partialAccessor) + or + result = getImmediateChildOfInterface(e, index, partialAccessor) + or + result = getImmediateChildOfLessThanExpression(e, index, partialAccessor) + or + result = getImmediateChildOfLessThanOrEqualExpression(e, index, partialAccessor) + or + result = getImmediateChildOfLikeExpression(e, index, partialAccessor) + or + result = getImmediateChildOfNamedTypeInternal(e, index, partialAccessor) + or + result = getImmediateChildOfNewClrCall(e, index, partialAccessor) + or + result = getImmediateChildOfNotEqualExpression(e, index, partialAccessor) + or + result = getImmediateChildOfQualifiedCall(e, index, partialAccessor) + or + result = getImmediateChildOfQualifiedStaticCall(e, index, partialAccessor) + or + result = getImmediateChildOfRealLiteralExpression(e, index, partialAccessor) + or + result = getImmediateChildOfStaticMethodCall(e, index, partialAccessor) + or + result = getImmediateChildOfStringLiteralExpression(e, index, partialAccessor) + or + result = getImmediateChildOfTableFieldDeclaration(e, index, partialAccessor) + or + result = getImmediateChildOfAssignDecrementStatement(e, index, partialAccessor) + or + result = getImmediateChildOfAssignDivideStatement(e, index, partialAccessor) + or + result = getImmediateChildOfAssignEqualStatement(e, index, partialAccessor) + or + result = getImmediateChildOfAssignIncrementStatement(e, index, partialAccessor) + or + result = getImmediateChildOfAssignMultiplyStatement(e, index, partialAccessor) + or + result = getImmediateChildOfAssignmentEventHandlerInstance(e, index, partialAccessor) + or + result = getImmediateChildOfParameterDeclaration(e, index, partialAccessor) + or + result = getImmediateChildOfVariableDeclarationInternal(e, index, partialAccessor) + or + result = getImmediateChildOfAssignmentEventHandlerClr(e, index, partialAccessor) + or + result = getImmediateChildOfAssignmentEventHandlerStaticInternal(e, index, partialAccessor) + } +} + +/** + * Gets the "immediate" parent of `e`. "Immediate" means not taking into account node resolution: for example + * if `e` has conversions, `getImmediateParent(e)` will give the innermost conversion in the hidden AST. + */ +Element getImmediateParent(Element e) { + // `unique` is used here to tell the optimizer that there is in fact only one result + // this is tested by the `library-tests/parent/no_double_parents.ql` test + result = unique(Element x | e = Impl::getImmediateChild(x, _, _) | x) +} + +/** + * Gets the immediate child indexed at `index`. Indexes are not guaranteed to be contiguous, but are guaranteed to be distinct. + */ +Element getImmediateChild(Element e, int index) { result = Impl::getImmediateChild(e, index, _) } + +/** + * Gets the immediate child indexed at `index`. Indexes are not guaranteed to be contiguous, but are guaranteed to be distinct. `accessor` is bound the member predicate call resulting in the given child. + */ +Element getImmediateChildAndAccessor(Element e, int index, string accessor) { + exists(string partialAccessor | + result = Impl::getImmediateChild(e, index, partialAccessor) and + accessor = "get" + partialAccessor + ) +} + +/** + * Gets the child indexed at `index`. Indexes are not guaranteed to be contiguous, but are guaranteed to be distinct. `accessor` is bound the member predicate call resulting in the given child. + */ +Element getChildAndAccessor(Element e, int index, string accessor) { + exists(string partialAccessor | + result = Impl::getImmediateChild(e, index, partialAccessor).resolve() and + accessor = "get" + partialAccessor + ) +} + +/** + * Gets the child indexed at `index`. Indexes are not guaranteed to be contiguous, but are guaranteed to be distinct. `accessor` is bound the member predicate call resulting in the given child. + */ +Element getChild(Element e, int index) { result = Impl::getImmediateChild(e, index, _).resolve() } diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/PhysicalAndExpression.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/PhysicalAndExpression.qll new file mode 100644 index 000000000000..c0a42d7717c8 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/PhysicalAndExpression.qll @@ -0,0 +1,25 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `PhysicalAndExpression`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.BinaryExpressionImpl::Impl as BinaryExpressionImpl + +/** + * INTERNAL: This module contains the fully generated definition of `PhysicalAndExpression` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::PhysicalAndExpression` class directly. + * Use the subclass `PhysicalAndExpression`, where the following predicates are available. + */ + class PhysicalAndExpression extends Synth::TPhysicalAndExpression, + BinaryExpressionImpl::BinaryExpression + { + override string getAPrimaryQlClass() { result = "PhysicalAndExpression" } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/PhysicalNotExpression.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/PhysicalNotExpression.qll new file mode 100644 index 000000000000..63128cd87d53 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/PhysicalNotExpression.qll @@ -0,0 +1,25 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `PhysicalNotExpression`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.UnaryExpressionImpl::Impl as UnaryExpressionImpl + +/** + * INTERNAL: This module contains the fully generated definition of `PhysicalNotExpression` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::PhysicalNotExpression` class directly. + * Use the subclass `PhysicalNotExpression`, where the following predicates are available. + */ + class PhysicalNotExpression extends Synth::TPhysicalNotExpression, + UnaryExpressionImpl::UnaryExpression + { + override string getAPrimaryQlClass() { result = "PhysicalNotExpression" } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/PhysicalOrExpression.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/PhysicalOrExpression.qll new file mode 100644 index 000000000000..a064be89452a --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/PhysicalOrExpression.qll @@ -0,0 +1,25 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `PhysicalOrExpression`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.BinaryExpressionImpl::Impl as BinaryExpressionImpl + +/** + * INTERNAL: This module contains the fully generated definition of `PhysicalOrExpression` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::PhysicalOrExpression` class directly. + * Use the subclass `PhysicalOrExpression`, where the following predicates are available. + */ + class PhysicalOrExpression extends Synth::TPhysicalOrExpression, + BinaryExpressionImpl::BinaryExpression + { + override string getAPrimaryQlClass() { result = "PhysicalOrExpression" } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/PhysicalXorExpression.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/PhysicalXorExpression.qll new file mode 100644 index 000000000000..bc53dd3afa46 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/PhysicalXorExpression.qll @@ -0,0 +1,25 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `PhysicalXorExpression`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.BinaryExpressionImpl::Impl as BinaryExpressionImpl + +/** + * INTERNAL: This module contains the fully generated definition of `PhysicalXorExpression` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::PhysicalXorExpression` class directly. + * Use the subclass `PhysicalXorExpression`, where the following predicates are available. + */ + class PhysicalXorExpression extends Synth::TPhysicalXorExpression, + BinaryExpressionImpl::BinaryExpression + { + override string getAPrimaryQlClass() { result = "PhysicalXorExpression" } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/Placeholder.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/Placeholder.qll new file mode 100644 index 000000000000..82ab8668e5ae --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/Placeholder.qll @@ -0,0 +1,23 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `Placeholder`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.ExpressionImpl::Impl as ExpressionImpl + +/** + * INTERNAL: This module contains the fully generated definition of `Placeholder` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::Placeholder` class directly. + * Use the subclass `Placeholder`, where the following predicates are available. + */ + class Placeholder extends Synth::TPlaceholder, ExpressionImpl::Expression { + override string getAPrimaryQlClass() { result = "Placeholder" } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/PrintStatement.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/PrintStatement.qll new file mode 100644 index 000000000000..d1c158375e5a --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/PrintStatement.qll @@ -0,0 +1,44 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `PrintStatement`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.Expression +import codeql.xpp.elements.internal.StatementImpl::Impl as StatementImpl + +/** + * INTERNAL: This module contains the fully generated definition of `PrintStatement` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::PrintStatement` class directly. + * Use the subclass `PrintStatement`, where the following predicates are available. + */ + class PrintStatement extends Synth::TPrintStatement, StatementImpl::Statement { + override string getAPrimaryQlClass() { result = "PrintStatement" } + + /** + * Gets the `index`th expression of this print statement (0-based). + */ + Expression getExpression(int index) { + result = + Synth::convertExpressionFromRaw(Synth::convertPrintStatementToRaw(this) + .(Raw::PrintStatement) + .getExpression(index)) + } + + /** + * Gets any of the expressions of this print statement. + */ + final Expression getAnExpression() { result = this.getExpression(_) } + + /** + * Gets the number of expressions of this print statement. + */ + final int getNumberOfExpressions() { result = count(int i | exists(this.getExpression(i))) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/ProvidedType.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/ProvidedType.qll new file mode 100644 index 000000000000..4fee7abdcfad --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/ProvidedType.qll @@ -0,0 +1,56 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `ProvidedType`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.Expression +import codeql.xpp.elements.internal.XppTypeImpl::Impl as XppTypeImpl + +/** + * INTERNAL: This module contains the fully generated definition of `ProvidedType` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::ProvidedType` class directly. + * Use the subclass `ProvidedType`, where the following predicates are available. + */ + class ProvidedType extends Synth::TProvidedType, XppTypeImpl::XppType { + override string getAPrimaryQlClass() { result = "ProvidedType" } + + /** + * Gets the `index`th argument list of this provided type (0-based). + */ + Expression getArgumentList(int index) { + result = + Synth::convertExpressionFromRaw(Synth::convertProvidedTypeToRaw(this) + .(Raw::ProvidedType) + .getArgumentList(index)) + } + + /** + * Gets any of the argument lists of this provided type. + */ + final Expression getAnArgumentList() { result = this.getArgumentList(_) } + + /** + * Gets the number of argument lists of this provided type. + */ + final int getNumberOfArgumentLists() { result = count(int i | exists(this.getArgumentList(i))) } + + /** + * Gets the name of this provided type, if it exists. + */ + string getName() { + result = Synth::convertProvidedTypeToRaw(this).(Raw::ProvidedType).getName() + } + + /** + * Holds if `getName()` exists. + */ + final predicate hasName() { exists(this.getName()) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/ProvidedTypeStaticCall.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/ProvidedTypeStaticCall.qll new file mode 100644 index 000000000000..549bcc226019 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/ProvidedTypeStaticCall.qll @@ -0,0 +1,54 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `ProvidedTypeStaticCall`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.EvaluationImpl::Impl as EvaluationImpl +import codeql.xpp.elements.ProvidedType + +/** + * INTERNAL: This module contains the fully generated definition of `ProvidedTypeStaticCall` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::ProvidedTypeStaticCall` class directly. + * Use the subclass `ProvidedTypeStaticCall`, where the following predicates are available. + */ + class ProvidedTypeStaticCall extends Synth::TProvidedTypeStaticCall, EvaluationImpl::Evaluation { + override string getAPrimaryQlClass() { result = "ProvidedTypeStaticCall" } + + /** + * Gets the method name of this provided type static call, if it exists. + */ + string getMethodName() { + result = + Synth::convertProvidedTypeStaticCallToRaw(this) + .(Raw::ProvidedTypeStaticCall) + .getMethodName() + } + + /** + * Holds if `getMethodName()` exists. + */ + final predicate hasMethodName() { exists(this.getMethodName()) } + + /** + * Gets the provided type of this provided type static call, if it exists. + */ + ProvidedType getProvidedType() { + result = + Synth::convertProvidedTypeFromRaw(Synth::convertProvidedTypeStaticCallToRaw(this) + .(Raw::ProvidedTypeStaticCall) + .getProvidedType()) + } + + /** + * Holds if `getProvidedType()` exists. + */ + final predicate hasProvidedType() { exists(this.getProvidedType()) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/PureSynthConstructors.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/PureSynthConstructors.qll new file mode 100644 index 000000000000..547b4755aeae --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/PureSynthConstructors.qll @@ -0,0 +1,5 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module exports all modules providing `Element` subclasses. + */ + diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/QualifiedCall.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/QualifiedCall.qll new file mode 100644 index 000000000000..73e950c60c6a --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/QualifiedCall.qll @@ -0,0 +1,51 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `QualifiedCall`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.GenericEvaluationImpl::Impl as GenericEvaluationImpl +import codeql.xpp.elements.Qualifier + +/** + * INTERNAL: This module contains the fully generated definition of `QualifiedCall` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::QualifiedCall` class directly. + * Use the subclass `QualifiedCall`, where the following predicates are available. + */ + class QualifiedCall extends Synth::TQualifiedCall, GenericEvaluationImpl::GenericEvaluation { + override string getAPrimaryQlClass() { result = "QualifiedCall" } + + /** + * Gets the method name of this qualified call, if it exists. + */ + string getMethodName() { + result = Synth::convertQualifiedCallToRaw(this).(Raw::QualifiedCall).getMethodName() + } + + /** + * Holds if `getMethodName()` exists. + */ + final predicate hasMethodName() { exists(this.getMethodName()) } + + /** + * Gets the qualifier of this qualified call, if it exists. + */ + Qualifier getQualifier() { + result = + Synth::convertQualifierFromRaw(Synth::convertQualifiedCallToRaw(this) + .(Raw::QualifiedCall) + .getQualifier()) + } + + /** + * Holds if `getQualifier()` exists. + */ + final predicate hasQualifier() { exists(this.getQualifier()) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/QualifiedField.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/QualifiedField.qll new file mode 100644 index 000000000000..280696c96645 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/QualifiedField.qll @@ -0,0 +1,47 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `QualifiedField`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.FieldSpecificationImpl::Impl as FieldSpecificationImpl + +/** + * INTERNAL: This module contains the fully generated definition of `QualifiedField` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::QualifiedField` class directly. + * Use the subclass `QualifiedField`, where the following predicates are available. + */ + class QualifiedField extends Synth::TQualifiedField, FieldSpecificationImpl::FieldSpecification { + override string getAPrimaryQlClass() { result = "QualifiedField" } + + /** + * Gets the extension name of this qualified field, if it exists. + */ + string getExtensionName() { + result = Synth::convertQualifiedFieldToRaw(this).(Raw::QualifiedField).getExtensionName() + } + + /** + * Holds if `getExtensionName()` exists. + */ + final predicate hasExtensionName() { exists(this.getExtensionName()) } + + /** + * Gets the name of this qualified field, if it exists. + */ + string getName() { + result = Synth::convertQualifiedFieldToRaw(this).(Raw::QualifiedField).getName() + } + + /** + * Holds if `getName()` exists. + */ + final predicate hasName() { exists(this.getName()) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/QualifiedInstanceName.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/QualifiedInstanceName.qll new file mode 100644 index 000000000000..4f37d30c8344 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/QualifiedInstanceName.qll @@ -0,0 +1,67 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `QualifiedInstanceName`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.Expression +import codeql.xpp.elements.internal.InstanceNameImpl::Impl as InstanceNameImpl +import codeql.xpp.elements.Qualifier + +/** + * INTERNAL: This module contains the fully generated definition of `QualifiedInstanceName` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::QualifiedInstanceName` class directly. + * Use the subclass `QualifiedInstanceName`, where the following predicates are available. + */ + class QualifiedInstanceName extends Synth::TQualifiedInstanceName, InstanceNameImpl::InstanceName { + override string getAPrimaryQlClass() { result = "QualifiedInstanceName" } + + /** + * Gets the index of this qualified instance name, if it exists. + */ + Expression getIndex() { + result = + Synth::convertExpressionFromRaw(Synth::convertQualifiedInstanceNameToRaw(this) + .(Raw::QualifiedInstanceName) + .getIndex()) + } + + /** + * Holds if `getIndex()` exists. + */ + final predicate hasIndex() { exists(this.getIndex()) } + + /** + * Gets the name of this qualified instance name, if it exists. + */ + string getName() { + result = Synth::convertQualifiedInstanceNameToRaw(this).(Raw::QualifiedInstanceName).getName() + } + + /** + * Holds if `getName()` exists. + */ + final predicate hasName() { exists(this.getName()) } + + /** + * Gets the qualifier of this qualified instance name, if it exists. + */ + Qualifier getQualifier() { + result = + Synth::convertQualifierFromRaw(Synth::convertQualifiedInstanceNameToRaw(this) + .(Raw::QualifiedInstanceName) + .getQualifier()) + } + + /** + * Holds if `getQualifier()` exists. + */ + final predicate hasQualifier() { exists(this.getQualifier()) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/QualifiedNumberedField.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/QualifiedNumberedField.qll new file mode 100644 index 000000000000..7af523a091ef --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/QualifiedNumberedField.qll @@ -0,0 +1,41 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `QualifiedNumberedField`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.Expression +import codeql.xpp.elements.internal.FieldSpecificationImpl::Impl as FieldSpecificationImpl + +/** + * INTERNAL: This module contains the fully generated definition of `QualifiedNumberedField` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::QualifiedNumberedField` class directly. + * Use the subclass `QualifiedNumberedField`, where the following predicates are available. + */ + class QualifiedNumberedField extends Synth::TQualifiedNumberedField, + FieldSpecificationImpl::FieldSpecification + { + override string getAPrimaryQlClass() { result = "QualifiedNumberedField" } + + /** + * Gets the field number of this qualified numbered field, if it exists. + */ + Expression getFieldNumber() { + result = + Synth::convertExpressionFromRaw(Synth::convertQualifiedNumberedFieldToRaw(this) + .(Raw::QualifiedNumberedField) + .getFieldNumber()) + } + + /** + * Holds if `getFieldNumber()` exists. + */ + final predicate hasFieldNumber() { exists(this.getFieldNumber()) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/QualifiedStaticCall.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/QualifiedStaticCall.qll new file mode 100644 index 000000000000..71d1e8419058 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/QualifiedStaticCall.qll @@ -0,0 +1,97 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `QualifiedStaticCall`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.GenericEvaluationImpl::Impl as GenericEvaluationImpl +import codeql.xpp.elements.Qualifier +import codeql.xpp.elements.XppType + +/** + * INTERNAL: This module contains the fully generated definition of `QualifiedStaticCall` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::QualifiedStaticCall` class directly. + * Use the subclass `QualifiedStaticCall`, where the following predicates are available. + */ + class QualifiedStaticCall extends Synth::TQualifiedStaticCall, + GenericEvaluationImpl::GenericEvaluation + { + override string getAPrimaryQlClass() { result = "QualifiedStaticCall" } + + /** + * Gets the class name of this qualified static call, if it exists. + */ + string getClassName() { + result = + Synth::convertQualifiedStaticCallToRaw(this).(Raw::QualifiedStaticCall).getClassName() + } + + /** + * Holds if `getClassName()` exists. + */ + final predicate hasClassName() { exists(this.getClassName()) } + + /** + * Gets the `index`th class type argument list of this qualified static call (0-based). + */ + XppType getClassTypeArgumentList(int index) { + result = + Synth::convertXppTypeFromRaw(Synth::convertQualifiedStaticCallToRaw(this) + .(Raw::QualifiedStaticCall) + .getClassTypeArgumentList(index)) + } + + /** + * Gets any of the class type argument lists of this qualified static call. + */ + final XppType getAClassTypeArgumentList() { result = this.getClassTypeArgumentList(_) } + + /** + * Gets the number of class type argument lists of this qualified static call. + */ + final int getNumberOfClassTypeArgumentLists() { + result = count(int i | exists(this.getClassTypeArgumentList(i))) + } + + /** + * Holds if this qualified static call is table map call. + */ + predicate isTableMapCall() { + Synth::convertQualifiedStaticCallToRaw(this).(Raw::QualifiedStaticCall).isTableMapCall() + } + + /** + * Gets the method name of this qualified static call, if it exists. + */ + string getMethodName() { + result = + Synth::convertQualifiedStaticCallToRaw(this).(Raw::QualifiedStaticCall).getMethodName() + } + + /** + * Holds if `getMethodName()` exists. + */ + final predicate hasMethodName() { exists(this.getMethodName()) } + + /** + * Gets the qualifier of this qualified static call, if it exists. + */ + Qualifier getQualifier() { + result = + Synth::convertQualifierFromRaw(Synth::convertQualifiedStaticCallToRaw(this) + .(Raw::QualifiedStaticCall) + .getQualifier()) + } + + /** + * Holds if `getQualifier()` exists. + */ + final predicate hasQualifier() { exists(this.getQualifier()) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/QualifiedStaticField.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/QualifiedStaticField.qll new file mode 100644 index 000000000000..819d3fa02859 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/QualifiedStaticField.qll @@ -0,0 +1,57 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `QualifiedStaticField`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.FieldSpecificationImpl::Impl as FieldSpecificationImpl + +/** + * INTERNAL: This module contains the fully generated definition of `QualifiedStaticField` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::QualifiedStaticField` class directly. + * Use the subclass `QualifiedStaticField`, where the following predicates are available. + */ + class QualifiedStaticField extends Synth::TQualifiedStaticField, + FieldSpecificationImpl::FieldSpecification + { + override string getAPrimaryQlClass() { result = "QualifiedStaticField" } + + /** + * Gets the class name of this qualified static field, if it exists. + */ + string getClassName() { + result = + Synth::convertQualifiedStaticFieldToRaw(this).(Raw::QualifiedStaticField).getClassName() + } + + /** + * Holds if `getClassName()` exists. + */ + final predicate hasClassName() { exists(this.getClassName()) } + + /** + * Holds if this qualified static field is enum. + */ + predicate isEnum() { + Synth::convertQualifiedStaticFieldToRaw(this).(Raw::QualifiedStaticField).isEnum() + } + + /** + * Gets the name of this qualified static field, if it exists. + */ + string getName() { + result = Synth::convertQualifiedStaticFieldToRaw(this).(Raw::QualifiedStaticField).getName() + } + + /** + * Holds if `getName()` exists. + */ + final predicate hasName() { exists(this.getName()) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/QualifiedStaticFieldExpression.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/QualifiedStaticFieldExpression.qll new file mode 100644 index 000000000000..4589cdc4b47c --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/QualifiedStaticFieldExpression.qll @@ -0,0 +1,64 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `QualifiedStaticFieldExpression`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.FieldExpressionImpl::Impl as FieldExpressionImpl + +/** + * INTERNAL: This module contains the fully generated definition of `QualifiedStaticFieldExpression` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::QualifiedStaticFieldExpression` class directly. + * Use the subclass `QualifiedStaticFieldExpression`, where the following predicates are available. + */ + class QualifiedStaticFieldExpression extends Synth::TQualifiedStaticFieldExpression, + FieldExpressionImpl::FieldExpression + { + override string getAPrimaryQlClass() { result = "QualifiedStaticFieldExpression" } + + /** + * Gets the class name of this qualified static field expression, if it exists. + */ + string getClassName() { + result = + Synth::convertQualifiedStaticFieldExpressionToRaw(this) + .(Raw::QualifiedStaticFieldExpression) + .getClassName() + } + + /** + * Holds if `getClassName()` exists. + */ + final predicate hasClassName() { exists(this.getClassName()) } + + /** + * Holds if this qualified static field expression is static. + */ + predicate isStatic() { + Synth::convertQualifiedStaticFieldExpressionToRaw(this) + .(Raw::QualifiedStaticFieldExpression) + .isStatic() + } + + /** + * Gets the name of this qualified static field expression, if it exists. + */ + string getName() { + result = + Synth::convertQualifiedStaticFieldExpressionToRaw(this) + .(Raw::QualifiedStaticFieldExpression) + .getName() + } + + /** + * Holds if `getName()` exists. + */ + final predicate hasName() { exists(this.getName()) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/Qualifier.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/Qualifier.qll new file mode 100644 index 000000000000..85d834784947 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/Qualifier.qll @@ -0,0 +1,21 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `Qualifier`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.AstImpl::Impl as AstImpl + +/** + * INTERNAL: This module contains the fully generated definition of `Qualifier` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::Qualifier` class directly. + * Use the subclass `Qualifier`, where the following predicates are available. + */ + class Qualifier extends Synth::TQualifier, AstImpl::Ast { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/Query.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/Query.qll new file mode 100644 index 000000000000..85dc43eb8956 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/Query.qll @@ -0,0 +1,188 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `Query`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.AstImpl::Impl as AstImpl +import codeql.xpp.elements.CrossCompany +import codeql.xpp.elements.Expression +import codeql.xpp.elements.JoinSpecification +import codeql.xpp.elements.OrderElement +import codeql.xpp.elements.Selection +import codeql.xpp.elements.ValidTimeState + +/** + * INTERNAL: This module contains the fully generated definition of `Query` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::Query` class directly. + * Use the subclass `Query`, where the following predicates are available. + */ + class Query extends Synth::TQuery, AstImpl::Ast { + override string getAPrimaryQlClass() { result = "Query" } + + /** + * Gets the buffer name of this query, if it exists. + */ + string getBufferName() { result = Synth::convertQueryToRaw(this).(Raw::Query).getBufferName() } + + /** + * Holds if `getBufferName()` exists. + */ + final predicate hasBufferName() { exists(this.getBufferName()) } + + /** + * Gets the cross company of this query, if it exists. + */ + CrossCompany getCrossCompany() { + result = + Synth::convertCrossCompanyFromRaw(Synth::convertQueryToRaw(this) + .(Raw::Query) + .getCrossCompany()) + } + + /** + * Holds if `getCrossCompany()` exists. + */ + final predicate hasCrossCompany() { exists(this.getCrossCompany()) } + + /** + * Gets the `index`th group by element of this query (0-based). + */ + OrderElement getGroupByElement(int index) { + result = + Synth::convertOrderElementFromRaw(Synth::convertQueryToRaw(this) + .(Raw::Query) + .getGroupByElement(index)) + } + + /** + * Gets any of the group by elements of this query. + */ + final OrderElement getAGroupByElement() { result = this.getGroupByElement(_) } + + /** + * Gets the number of group by elements of this query. + */ + final int getNumberOfGroupByElements() { + result = count(int i | exists(this.getGroupByElement(i))) + } + + /** + * Gets the index name of this query, if it exists. + */ + string getIndexName() { result = Synth::convertQueryToRaw(this).(Raw::Query).getIndexName() } + + /** + * Holds if `getIndexName()` exists. + */ + final predicate hasIndexName() { exists(this.getIndexName()) } + + /** + * Gets the joins of this query, if it exists. + */ + JoinSpecification getJoins() { + result = + Synth::convertJoinSpecificationFromRaw(Synth::convertQueryToRaw(this) + .(Raw::Query) + .getJoins()) + } + + /** + * Holds if `getJoins()` exists. + */ + final predicate hasJoins() { exists(this.getJoins()) } + + /** + * Gets the `index`th order by element of this query (0-based). + */ + OrderElement getOrderByElement(int index) { + result = + Synth::convertOrderElementFromRaw(Synth::convertQueryToRaw(this) + .(Raw::Query) + .getOrderByElement(index)) + } + + /** + * Gets any of the order by elements of this query. + */ + final OrderElement getAnOrderByElement() { result = this.getOrderByElement(_) } + + /** + * Gets the number of order by elements of this query. + */ + final int getNumberOfOrderByElements() { + result = count(int i | exists(this.getOrderByElement(i))) + } + + /** + * Gets the selection of this query, if it exists. + */ + Selection getSelection() { + result = + Synth::convertSelectionFromRaw(Synth::convertQueryToRaw(this).(Raw::Query).getSelection()) + } + + /** + * Holds if `getSelection()` exists. + */ + final predicate hasSelection() { exists(this.getSelection()) } + + /** + * Gets the `index`th selection hint of this query (0-based). + */ + string getSelectionHint(int index) { + result = Synth::convertQueryToRaw(this).(Raw::Query).getSelectionHint(index) + } + + /** + * Gets any of the selection hints of this query. + */ + final string getASelectionHint() { result = this.getSelectionHint(_) } + + /** + * Gets the number of selection hints of this query. + */ + final int getNumberOfSelectionHints() { + result = count(int i | exists(this.getSelectionHint(i))) + } + + /** + * Holds if this query uses hint. + */ + predicate usesHint() { Synth::convertQueryToRaw(this).(Raw::Query).usesHint() } + + /** + * Gets the valid time state of this query, if it exists. + */ + ValidTimeState getValidTimeState() { + result = + Synth::convertValidTimeStateFromRaw(Synth::convertQueryToRaw(this) + .(Raw::Query) + .getValidTimeState()) + } + + /** + * Holds if `getValidTimeState()` exists. + */ + final predicate hasValidTimeState() { exists(this.getValidTimeState()) } + + /** + * Gets the where of this query, if it exists. + */ + Expression getWhere() { + result = + Synth::convertExpressionFromRaw(Synth::convertQueryToRaw(this).(Raw::Query).getWhere()) + } + + /** + * Holds if `getWhere()` exists. + */ + final predicate hasWhere() { exists(this.getWhere()) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/QueryDataSource.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/QueryDataSource.qll new file mode 100644 index 000000000000..2c960587b189 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/QueryDataSource.qll @@ -0,0 +1,280 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `QueryDataSource`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.AstImpl::Impl as AstImpl +import codeql.xpp.elements.GlobalOrderElement +import codeql.xpp.elements.QueryDataSource +import codeql.xpp.elements.QueryDataSourceHaving +import codeql.xpp.elements.QueryDataSourceRange +import codeql.xpp.elements.QueryDataSourceRelation + +private class QueryDataSourceAlias = QueryDataSource; + +/** + * INTERNAL: This module contains the fully generated definition of `QueryDataSource` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::QueryDataSource` class directly. + * Use the subclass `QueryDataSource`, where the following predicates are available. + */ + class QueryDataSource extends Synth::TQueryDataSource, AstImpl::Ast { + override string getAPrimaryQlClass() { result = "QueryDataSource" } + + /** + * Gets the `index`th data source of this query data source (0-based). + */ + QueryDataSourceAlias getDataSource(int index) { + result = + Synth::convertQueryDataSourceFromRaw(Synth::convertQueryDataSourceToRaw(this) + .(Raw::QueryDataSource) + .getDataSource(index)) + } + + /** + * Gets any of the data sources of this query data source. + */ + final QueryDataSourceAlias getADataSource() { result = this.getDataSource(_) } + + /** + * Gets the number of data sources of this query data source. + */ + final int getNumberOfDataSources() { result = count(int i | exists(this.getDataSource(i))) } + + /** + * Gets the element type name of this query data source, if it exists. + */ + string getElementTypeName() { + result = Synth::convertQueryDataSourceToRaw(this).(Raw::QueryDataSource).getElementTypeName() + } + + /** + * Holds if `getElementTypeName()` exists. + */ + final predicate hasElementTypeName() { exists(this.getElementTypeName()) } + + /** + * Gets the fetch mode of this query data source, if it exists. + */ + string getFetchMode() { + result = Synth::convertQueryDataSourceToRaw(this).(Raw::QueryDataSource).getFetchMode() + } + + /** + * Holds if `getFetchMode()` exists. + */ + final predicate hasFetchMode() { exists(this.getFetchMode()) } + + /** + * Gets the `index`th field of this query data source (0-based). + */ + string getField(int index) { + result = Synth::convertQueryDataSourceToRaw(this).(Raw::QueryDataSource).getField(index) + } + + /** + * Gets any of the fields of this query data source. + */ + final string getAField() { result = this.getField(_) } + + /** + * Gets the number of fields of this query data source. + */ + final int getNumberOfFields() { result = count(int i | exists(this.getField(i))) } + + /** + * Holds if this query data source first fast. + */ + predicate firstFast() { + Synth::convertQueryDataSourceToRaw(this).(Raw::QueryDataSource).firstFast() + } + + /** + * Holds if this query data source first only. + */ + predicate firstOnly() { + Synth::convertQueryDataSourceToRaw(this).(Raw::QueryDataSource).firstOnly() + } + + /** + * Gets the `index`th group by of this query data source (0-based). + */ + GlobalOrderElement getGroupBy(int index) { + result = + Synth::convertGlobalOrderElementFromRaw(Synth::convertQueryDataSourceToRaw(this) + .(Raw::QueryDataSource) + .getGroupBy(index)) + } + + /** + * Gets any of the group bies of this query data source. + */ + final GlobalOrderElement getAGroupBy() { result = this.getGroupBy(_) } + + /** + * Gets the number of group bies of this query data source. + */ + final int getNumberOfGroupBies() { result = count(int i | exists(this.getGroupBy(i))) } + + /** + * Gets the `index`th having of this query data source (0-based). + */ + QueryDataSourceHaving getHaving(int index) { + result = + Synth::convertQueryDataSourceHavingFromRaw(Synth::convertQueryDataSourceToRaw(this) + .(Raw::QueryDataSource) + .getHaving(index)) + } + + /** + * Gets any of the havings of this query data source. + */ + final QueryDataSourceHaving getAHaving() { result = this.getHaving(_) } + + /** + * Gets the number of havings of this query data source. + */ + final int getNumberOfHavings() { result = count(int i | exists(this.getHaving(i))) } + + /** + * Gets the join mode of this query data source, if it exists. + */ + string getJoinMode() { + result = Synth::convertQueryDataSourceToRaw(this).(Raw::QueryDataSource).getJoinMode() + } + + /** + * Holds if `getJoinMode()` exists. + */ + final predicate hasJoinMode() { exists(this.getJoinMode()) } + + /** + * Gets the name of this query data source, if it exists. + */ + string getName() { + result = Synth::convertQueryDataSourceToRaw(this).(Raw::QueryDataSource).getName() + } + + /** + * Holds if `getName()` exists. + */ + final predicate hasName() { exists(this.getName()) } + + /** + * Gets the `index`th order by of this query data source (0-based). + */ + GlobalOrderElement getOrderBy(int index) { + result = + Synth::convertGlobalOrderElementFromRaw(Synth::convertQueryDataSourceToRaw(this) + .(Raw::QueryDataSource) + .getOrderBy(index)) + } + + /** + * Gets any of the order bies of this query data source. + */ + final GlobalOrderElement getAnOrderBy() { result = this.getOrderBy(_) } + + /** + * Gets the number of order bies of this query data source. + */ + final int getNumberOfOrderBies() { result = count(int i | exists(this.getOrderBy(i))) } + + /** + * Gets the parent data source of this query data source, if it exists. + */ + QueryDataSourceAlias getParentDataSource() { + result = + Synth::convertQueryDataSourceFromRaw(Synth::convertQueryDataSourceToRaw(this) + .(Raw::QueryDataSource) + .getParentDataSource()) + } + + /** + * Holds if `getParentDataSource()` exists. + */ + final predicate hasParentDataSource() { exists(this.getParentDataSource()) } + + /** + * Gets the path contribution of this query data source, if it exists. + */ + string getPathContribution() { + result = Synth::convertQueryDataSourceToRaw(this).(Raw::QueryDataSource).getPathContribution() + } + + /** + * Holds if `getPathContribution()` exists. + */ + final predicate hasPathContribution() { exists(this.getPathContribution()) } + + /** + * Gets the `index`th range of this query data source (0-based). + */ + QueryDataSourceRange getRange(int index) { + result = + Synth::convertQueryDataSourceRangeFromRaw(Synth::convertQueryDataSourceToRaw(this) + .(Raw::QueryDataSource) + .getRange(index)) + } + + /** + * Gets any of the ranges of this query data source. + */ + final QueryDataSourceRange getARange() { result = this.getRange(_) } + + /** + * Gets the number of ranges of this query data source. + */ + final int getNumberOfRanges() { result = count(int i | exists(this.getRange(i))) } + + /** + * Gets the `index`th relation of this query data source (0-based). + */ + QueryDataSourceRelation getRelation(int index) { + result = + Synth::convertQueryDataSourceRelationFromRaw(Synth::convertQueryDataSourceToRaw(this) + .(Raw::QueryDataSource) + .getRelation(index)) + } + + /** + * Gets any of the relations of this query data source. + */ + final QueryDataSourceRelation getARelation() { result = this.getRelation(_) } + + /** + * Gets the number of relations of this query data source. + */ + final int getNumberOfRelations() { result = count(int i | exists(this.getRelation(i))) } + + /** + * Holds if this query data source select with repeatable read. + */ + predicate selectWithRepeatableRead() { + Synth::convertQueryDataSourceToRaw(this).(Raw::QueryDataSource).selectWithRepeatableRead() + } + + /** + * Gets the table of this query data source, if it exists. + */ + string getTable() { + result = Synth::convertQueryDataSourceToRaw(this).(Raw::QueryDataSource).getTable() + } + + /** + * Holds if `getTable()` exists. + */ + final predicate hasTable() { exists(this.getTable()) } + + /** + * Holds if this query data source update. + */ + predicate update() { Synth::convertQueryDataSourceToRaw(this).(Raw::QueryDataSource).update() } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/QueryDataSourceHaving.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/QueryDataSourceHaving.qll new file mode 100644 index 000000000000..fa495f080ffa --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/QueryDataSourceHaving.qll @@ -0,0 +1,67 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `QueryDataSourceHaving`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.AstImpl::Impl as AstImpl +import codeql.xpp.elements.SelectionField + +/** + * INTERNAL: This module contains the fully generated definition of `QueryDataSourceHaving` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::QueryDataSourceHaving` class directly. + * Use the subclass `QueryDataSourceHaving`, where the following predicates are available. + */ + class QueryDataSourceHaving extends Synth::TQueryDataSourceHaving, AstImpl::Ast { + override string getAPrimaryQlClass() { result = "QueryDataSourceHaving" } + + /** + * Gets the data source name of this query data source having, if it exists. + */ + string getDataSourceName() { + result = + Synth::convertQueryDataSourceHavingToRaw(this) + .(Raw::QueryDataSourceHaving) + .getDataSourceName() + } + + /** + * Holds if `getDataSourceName()` exists. + */ + final predicate hasDataSourceName() { exists(this.getDataSourceName()) } + + /** + * Gets the selection of this query data source having, if it exists. + */ + SelectionField getSelection() { + result = + Synth::convertSelectionFieldFromRaw(Synth::convertQueryDataSourceHavingToRaw(this) + .(Raw::QueryDataSourceHaving) + .getSelection()) + } + + /** + * Holds if `getSelection()` exists. + */ + final predicate hasSelection() { exists(this.getSelection()) } + + /** + * Gets the value of this query data source having, if it exists. + */ + string getValue() { + result = + Synth::convertQueryDataSourceHavingToRaw(this).(Raw::QueryDataSourceHaving).getValue() + } + + /** + * Holds if `getValue()` exists. + */ + final predicate hasValue() { exists(this.getValue()) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/QueryDataSourceRange.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/QueryDataSourceRange.qll new file mode 100644 index 000000000000..ec2b14a8d58d --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/QueryDataSourceRange.qll @@ -0,0 +1,47 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `QueryDataSourceRange`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.AstImpl::Impl as AstImpl + +/** + * INTERNAL: This module contains the fully generated definition of `QueryDataSourceRange` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::QueryDataSourceRange` class directly. + * Use the subclass `QueryDataSourceRange`, where the following predicates are available. + */ + class QueryDataSourceRange extends Synth::TQueryDataSourceRange, AstImpl::Ast { + override string getAPrimaryQlClass() { result = "QueryDataSourceRange" } + + /** + * Gets the field of this query data source range, if it exists. + */ + string getField() { + result = Synth::convertQueryDataSourceRangeToRaw(this).(Raw::QueryDataSourceRange).getField() + } + + /** + * Holds if `getField()` exists. + */ + final predicate hasField() { exists(this.getField()) } + + /** + * Gets the value of this query data source range, if it exists. + */ + string getValue() { + result = Synth::convertQueryDataSourceRangeToRaw(this).(Raw::QueryDataSourceRange).getValue() + } + + /** + * Holds if `getValue()` exists. + */ + final predicate hasValue() { exists(this.getValue()) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/QueryDataSourceRelation.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/QueryDataSourceRelation.qll new file mode 100644 index 000000000000..c2e121da3226 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/QueryDataSourceRelation.qll @@ -0,0 +1,66 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `QueryDataSourceRelation`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.AstImpl::Impl as AstImpl + +/** + * INTERNAL: This module contains the fully generated definition of `QueryDataSourceRelation` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::QueryDataSourceRelation` class directly. + * Use the subclass `QueryDataSourceRelation`, where the following predicates are available. + */ + class QueryDataSourceRelation extends Synth::TQueryDataSourceRelation, AstImpl::Ast { + override string getAPrimaryQlClass() { result = "QueryDataSourceRelation" } + + /** + * Gets the field of this query data source relation, if it exists. + */ + string getField() { + result = + Synth::convertQueryDataSourceRelationToRaw(this).(Raw::QueryDataSourceRelation).getField() + } + + /** + * Holds if `getField()` exists. + */ + final predicate hasField() { exists(this.getField()) } + + /** + * Gets the join data source of this query data source relation, if it exists. + */ + string getJoinDataSource() { + result = + Synth::convertQueryDataSourceRelationToRaw(this) + .(Raw::QueryDataSourceRelation) + .getJoinDataSource() + } + + /** + * Holds if `getJoinDataSource()` exists. + */ + final predicate hasJoinDataSource() { exists(this.getJoinDataSource()) } + + /** + * Gets the related field of this query data source relation, if it exists. + */ + string getRelatedField() { + result = + Synth::convertQueryDataSourceRelationToRaw(this) + .(Raw::QueryDataSourceRelation) + .getRelatedField() + } + + /** + * Holds if `getRelatedField()` exists. + */ + final predicate hasRelatedField() { exists(this.getRelatedField()) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/QueryModelElement.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/QueryModelElement.qll new file mode 100644 index 000000000000..36461e60d9f9 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/QueryModelElement.qll @@ -0,0 +1,109 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `QueryModelElement`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.Class +import codeql.xpp.elements.internal.ModelElementImpl::Impl as ModelElementImpl +import codeql.xpp.elements.QueryDataSource + +/** + * INTERNAL: This module contains the fully generated definition of `QueryModelElement` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::QueryModelElement` class directly. + * Use the subclass `QueryModelElement`, where the following predicates are available. + */ + class QueryModelElement extends Synth::TQueryModelElement, ModelElementImpl::ModelElement { + override string getAPrimaryQlClass() { result = "QueryModelElement" } + + /** + * Holds if this query model element allow cross company. + */ + predicate allowCrossCompany() { + Synth::convertQueryModelElementToRaw(this).(Raw::QueryModelElement).allowCrossCompany() + } + + /** + * Gets the behavior of this query model element, if it exists. + */ + Class getBehavior() { + result = + Synth::convertClassFromRaw(Synth::convertQueryModelElementToRaw(this) + .(Raw::QueryModelElement) + .getBehavior()) + } + + /** + * Holds if `getBehavior()` exists. + */ + final predicate hasBehavior() { exists(this.getBehavior()) } + + /** + * Gets the `index`th data source list of this query model element (0-based). + */ + QueryDataSource getDataSourceList(int index) { + result = + Synth::convertQueryDataSourceFromRaw(Synth::convertQueryModelElementToRaw(this) + .(Raw::QueryModelElement) + .getDataSourceList(index)) + } + + /** + * Gets any of the data source lists of this query model element. + */ + final QueryDataSource getADataSourceList() { result = this.getDataSourceList(_) } + + /** + * Gets the number of data source lists of this query model element. + */ + final int getNumberOfDataSourceLists() { + result = count(int i | exists(this.getDataSourceList(i))) + } + + /** + * Gets the `index`th data source of this query model element (0-based). + */ + QueryDataSource getDataSource(int index) { + result = + Synth::convertQueryDataSourceFromRaw(Synth::convertQueryModelElementToRaw(this) + .(Raw::QueryModelElement) + .getDataSource(index)) + } + + /** + * Gets any of the data sources of this query model element. + */ + final QueryDataSource getADataSource() { result = this.getDataSource(_) } + + /** + * Gets the number of data sources of this query model element. + */ + final int getNumberOfDataSources() { result = count(int i | exists(this.getDataSource(i))) } + + /** + * Gets the element type name of this query model element, if it exists. + */ + string getElementTypeName() { + result = + Synth::convertQueryModelElementToRaw(this).(Raw::QueryModelElement).getElementTypeName() + } + + /** + * Holds if `getElementTypeName()` exists. + */ + final predicate hasElementTypeName() { exists(this.getElementTypeName()) } + + /** + * Holds if this query model element user update. + */ + predicate userUpdate() { + Synth::convertQueryModelElementToRaw(this).(Raw::QueryModelElement).userUpdate() + } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/Raw.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/Raw.qll new file mode 100644 index 000000000000..fcbcc13b1cfb --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/Raw.qll @@ -0,0 +1,7621 @@ +/** + * INTERNAL: Do not use. + * This module holds thin fully generated class definitions around DB entities. + */ +module Raw { + /** + * INTERNAL: Do not use. + */ + class Element extends @element { + string toString() { none() } + + /** + * Holds if this element is unknown. + */ + predicate isUnknown() { element_is_unknown(this) } + } + + /** + * INTERNAL: Do not use. + */ + class File extends @file, Element { + override string toString() { result = "File" } + + /** + * Gets the name of this file. + */ + string getName() { files(this, result) } + } + + private Element getImmediateChildOfFile(File e, int index) { none() } + + /** + * INTERNAL: Do not use. + */ + class Locatable extends @locatable, Element { + /** + * Gets the location associated with this element in the code, if it exists. + */ + Location getLocation() { locatable_locations(this, result) } + } + + /** + * INTERNAL: Do not use. + */ + class Location extends @location, Element { + override string toString() { result = "Location" } + + /** + * Gets the file of this location. + */ + File getFile() { locations(this, result, _, _, _, _) } + + /** + * Gets the start line of this location. + */ + int getStartLine() { locations(this, _, result, _, _, _) } + + /** + * Gets the start column of this location. + */ + int getStartColumn() { locations(this, _, _, result, _, _) } + + /** + * Gets the end line of this location. + */ + int getEndLine() { locations(this, _, _, _, result, _) } + + /** + * Gets the end column of this location. + */ + int getEndColumn() { locations(this, _, _, _, _, result) } + } + + private Element getImmediateChildOfLocation(Location e, int index) { none() } + + /** + * INTERNAL: Do not use. + * Root of the X++ abstract syntax tree. + * + * This mirrors `Microsoft.Dynamics.AX.Metadata.XppCompiler.Ast`, the base class of the + * X++ compiler's own AST. + */ + class Ast extends @ast, Locatable { } + + /** + * INTERNAL: Do not use. + * A comment in X++ source. + */ + class Comment extends @comment, Locatable { + override string toString() { result = "Comment" } + + /** + * Gets the text of this comment, if it exists. + */ + string getText() { comment_texts(this, result) } + } + + private Element getImmediateChildOfComment(Comment e, int index) { none() } + + /** + * INTERNAL: Do not use. + * The superclass of all elements indicating some kind of error. + */ + class ErrorElement extends @error_element, Locatable { } + + /** + * INTERNAL: Do not use. + * Base of the classes standing in for tuples in the compiler's AST. + * + * The X++ compiler uses CLR tuples for a handful of grouped values, such as a `catch` + * together with its handler body. The schema has no tuple type, so the generator emits a + * named class per tuple-valued property instead. + */ + class XppTuple extends @xpp_tuple, Locatable { } + + /** + * INTERNAL: Do not use. + */ + class ArraySpecification extends @array_specification, Ast { + override string toString() { result = "ArraySpecification" } + + /** + * Gets the index1 of this array specification, if it exists. + */ + Expression getIndex1() { array_specification_index1s(this, result) } + + /** + * Gets the index2 of this array specification, if it exists. + */ + Expression getIndex2() { array_specification_index2s(this, result) } + } + + private Element getImmediateChildOfArraySpecification(ArraySpecification e, int index) { + exists(int n, int nIndex1, int nIndex2 | + n = 0 and + nIndex1 = n + 1 and + nIndex2 = nIndex1 + 1 and + ( + none() + or + index = n and result = e.getIndex1() + or + index = nIndex1 and result = e.getIndex2() + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class Attribute extends @attribute, Ast { + override string toString() { result = "Attribute" } + + /** + * Gets the name of this attribute, if it exists. + */ + string getName() { attribute_names(this, result) } + + /** + * Gets the `index`th named parameter of this attribute (0-based). + */ + AttributeNamedParameterEntry getNamedParameter(int index) { + attribute_named_parameters(this, index, result) + } + + /** + * Gets the number of named parameters of this attribute. + */ + int getNumberOfNamedParameters() { + result = count(int i | attribute_named_parameters(this, i, _)) + } + + /** + * Gets the non fully qualified name of this attribute, if it exists. + */ + string getNonFullyQualifiedName() { attribute_non_fully_qualified_names(this, result) } + + /** + * Gets the `index`th parameter of this attribute (0-based). + */ + AttributeExpression getParameter(int index) { attribute_parameters(this, index, result) } + + /** + * Gets the number of parameters of this attribute. + */ + int getNumberOfParameters() { result = count(int i | attribute_parameters(this, i, _)) } + } + + private Element getImmediateChildOfAttribute(Attribute e, int index) { + exists(int n, int nNamedParameter, int nParameter | + n = 0 and + nNamedParameter = n + e.getNumberOfNamedParameters() and + nParameter = nNamedParameter + e.getNumberOfParameters() and + ( + none() + or + result = e.getNamedParameter(index - n) + or + result = e.getParameter(index - nNamedParameter) + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class AttributeExpression extends @attribute_expression, Ast { + override string toString() { result = "AttributeExpression" } + + /** + * Gets the literal of this attribute expression, if it exists. + */ + AttributeLiteral getLiteral() { attribute_expression_literals(this, result) } + } + + private Element getImmediateChildOfAttributeExpression(AttributeExpression e, int index) { + exists(int n, int nLiteral | + n = 0 and + nLiteral = n + 1 and + ( + none() + or + index = n and result = e.getLiteral() + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class AttributeList extends @attribute_list, Ast { + override string toString() { result = "AttributeList" } + + /** + * Gets the `index`th attribute of this attribute list (0-based). + */ + Attribute getAttribute(int index) { attribute_list_attributes(this, index, result) } + + /** + * Gets the number of attributes of this attribute list. + */ + int getNumberOfAttributes() { result = count(int i | attribute_list_attributes(this, i, _)) } + + /** + * Holds if this attribute list contains internal use only attribute. + */ + predicate containsInternalUseOnlyAttribute() { + attribute_list_contains_internal_use_only_attribute(this) + } + } + + private Element getImmediateChildOfAttributeList(AttributeList e, int index) { + exists(int n, int nAttribute | + n = 0 and + nAttribute = n + e.getNumberOfAttributes() and + ( + none() + or + result = e.getAttribute(index - n) + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class AttributeLiteral extends @attribute_literal, Ast { } + + /** + * INTERNAL: Do not use. + */ + class AttributeNamedParameterEntry extends @attribute_named_parameter_entry, XppTuple { + override string toString() { result = "AttributeNamedParameterEntry" } + + /** + * Gets the item1 of this attribute named parameter entry, if it exists. + */ + string getItem1() { attribute_named_parameter_entry_item1s(this, result) } + + /** + * Gets the attribute expression of this attribute named parameter entry, if it exists. + */ + AttributeExpression getAttributeExpression() { + attribute_named_parameter_entry_attribute_expressions(this, result) + } + } + + private Element getImmediateChildOfAttributeNamedParameterEntry( + AttributeNamedParameterEntry e, int index + ) { + exists(int n, int nAttributeExpression | + n = 0 and + nAttributeExpression = n + 1 and + ( + none() + or + index = n and result = e.getAttributeExpression() + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class Case extends @case, Ast { } + + /** + * INTERNAL: Do not use. + */ + class Catch extends @catch, Ast { } + + /** + * INTERNAL: Do not use. + */ + class ClassAccessModifier extends @class_access_modifier, Ast { + override string toString() { result = "ClassAccessModifier" } + + /** + * Gets the class modifiers of this class access modifier, if it exists. + */ + string getClassModifiers() { class_access_modifier_class_modifiers(this, result) } + } + + private Element getImmediateChildOfClassAccessModifier(ClassAccessModifier e, int index) { + none() + } + + /** + * INTERNAL: Do not use. + */ + class CompilationUnit extends @compilation_unit, Ast { + /** + * Gets the comments of this compilation unit, if it exists. + */ + Comment getComments() { compilation_unit_comments(this, result) } + + /** + * Holds if this compilation unit is name escaped. + */ + predicate isNameEscaped() { compilation_unit_is_name_escaped(this) } + + /** + * Gets the name of this compilation unit, if it exists. + */ + string getName() { compilation_unit_names(this, result) } + + /** + * Holds if this compilation unit needs transformation. + */ + predicate needsTransformation() { compilation_unit_needs_transformation(this) } + + /** + * Gets the `index`th region of this compilation unit (0-based). + */ + CompilationUnitRegionEntry getRegion(int index) { + compilation_unit_regions(this, index, result) + } + + /** + * Gets the number of regions of this compilation unit. + */ + int getNumberOfRegions() { result = count(int i | compilation_unit_regions(this, i, _)) } + } + + /** + * INTERNAL: Do not use. + */ + class CompilationUnitRegionEntry extends @compilation_unit_region_entry, XppTuple { + override string toString() { result = "CompilationUnitRegionEntry" } + + /** + * Gets the comment of this compilation unit region entry, if it exists. + */ + Comment getComment() { compilation_unit_region_entry_comments(this, result) } + + /** + * Gets the comment2 of this compilation unit region entry, if it exists. + */ + Comment getComment2() { compilation_unit_region_entry_comment2s(this, result) } + } + + private Element getImmediateChildOfCompilationUnitRegionEntry( + CompilationUnitRegionEntry e, int index + ) { + exists(int n, int nComment, int nComment2 | + n = 0 and + nComment = n + 1 and + nComment2 = nComment + 1 and + ( + none() + or + index = n and result = e.getComment() + or + index = nComment and result = e.getComment2() + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class CrossCompany extends @cross_company, Ast { } + + /** + * INTERNAL: Do not use. + */ + class EvaluationActualParameterEntry extends @evaluation_actual_parameter_entry, XppTuple { + override string toString() { result = "EvaluationActualParameterEntry" } + + /** + * Holds if this evaluation actual parameter entry item1. + */ + predicate item1() { evaluation_actual_parameter_entry_item1(this) } + + /** + * Gets the expression of this evaluation actual parameter entry, if it exists. + */ + Expression getExpression() { evaluation_actual_parameter_entry_expressions(this, result) } + } + + private Element getImmediateChildOfEvaluationActualParameterEntry( + EvaluationActualParameterEntry e, int index + ) { + exists(int n, int nExpression | + n = 0 and + nExpression = n + 1 and + ( + none() + or + index = n and result = e.getExpression() + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class Expression extends @expression, Ast { + /** + * Holds if this expression is const. + */ + predicate isConst() { expression_is_const(this) } + + /** + * Gets the transformation of this expression, if it exists. + */ + Expression getTransformation() { expression_transformations(this, result) } + } + + /** + * INTERNAL: Do not use. + */ + class FieldAssignment extends @field_assignment, Ast { + override string toString() { result = "FieldAssignment" } + + /** + * Gets the expression of this field assignment, if it exists. + */ + Expression getExpression() { field_assignment_expressions(this, result) } + + /** + * Gets the extension name of this field assignment, if it exists. + */ + string getExtensionName() { field_assignment_extension_names(this, result) } + + /** + * Gets the field name of this field assignment, if it exists. + */ + string getFieldName() { field_assignment_field_names(this, result) } + + /** + * Gets the index of this field assignment, if it exists. + */ + int getIndex() { field_assignment_indices(this, result) } + } + + private Element getImmediateChildOfFieldAssignment(FieldAssignment e, int index) { + exists(int n, int nExpression | + n = 0 and + nExpression = n + 1 and + ( + none() + or + index = n and result = e.getExpression() + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class FieldSpecification extends @field_specification, Ast { + /** + * Gets the array index of this field specification, if it exists. + */ + Expression getArrayIndex() { field_specification_array_indices(this, result) } + + /** + * Gets the element type name of this field specification, if it exists. + */ + string getElementTypeName() { field_specification_element_type_names(this, result) } + + /** + * Holds if this field specification is const. + */ + predicate isConst() { field_specification_is_const(this) } + + /** + * Holds if this field specification is internal. + */ + predicate isInternal() { field_specification_is_internal(this) } + + /** + * Holds if this field specification is private. + */ + predicate isPrivate() { field_specification_is_private(this) } + + /** + * Holds if this field specification is protected. + */ + predicate isProtected() { field_specification_is_protected(this) } + + /** + * Holds if this field specification is public. + */ + predicate isPublic() { field_specification_is_public(this) } + + /** + * Holds if this field specification is read only. + */ + predicate isReadOnly() { field_specification_is_read_only(this) } + + /** + * Holds if this field specification is static. + */ + predicate isStatic() { field_specification_is_static(this) } + + /** + * Gets the qualifier of this field specification, if it exists. + */ + Qualifier getQualifier() { field_specification_qualifiers(this, result) } + } + + /** + * INTERNAL: Do not use. + */ + class ForAssign extends @for_assign, Ast { + /** + * Gets the field specification of this for assign, if it exists. + */ + FieldSpecification getFieldSpecification() { for_assign_field_specifications(this, result) } + } + + /** + * INTERNAL: Do not use. + */ + class InsertFieldSpecification extends @insert_field_specification, Ast { + override string toString() { result = "InsertFieldSpecification" } + + /** + * Gets the array index of this insert field specification, if it exists. + */ + int getArrayIndex() { insert_field_specification_array_indices(this, result) } + + /** + * Gets the extension name of this insert field specification, if it exists. + */ + string getExtensionName() { insert_field_specification_extension_names(this, result) } + + /** + * Holds if this insert field specification is extension. + */ + predicate isExtension() { insert_field_specification_is_extension(this) } + + /** + * Gets the name of this insert field specification, if it exists. + */ + string getName() { insert_field_specification_names(this, result) } + } + + private Element getImmediateChildOfInsertFieldSpecification(InsertFieldSpecification e, int index) { + none() + } + + /** + * INTERNAL: Do not use. + */ + class InstanceName extends @instance_name, Ast { } + + /** + * INTERNAL: Do not use. + */ + class JoinSpecification extends @join_specification, Ast { + override string toString() { result = "JoinSpecification" } + + /** + * Gets the kind of this join specification, if it exists. + */ + string getKind() { join_specification_kinds(this, result) } + + /** + * Gets the query of this join specification, if it exists. + */ + Query getQuery() { join_specification_queries(this, result) } + } + + private Element getImmediateChildOfJoinSpecification(JoinSpecification e, int index) { + exists(int n, int nQuery | + n = 0 and + nQuery = n + 1 and + ( + none() + or + index = n and result = e.getQuery() + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class ModelElementUsingEntry extends @model_element_using_entry, XppTuple { + override string toString() { result = "ModelElementUsingEntry" } + + /** + * Gets the item2 of this model element using entry, if it exists. + */ + string getItem2() { model_element_using_entry_item2s(this, result) } + + /** + * Gets the item3 of this model element using entry, if it exists. + */ + string getItem3() { model_element_using_entry_item3s(this, result) } + } + + private Element getImmediateChildOfModelElementUsingEntry(ModelElementUsingEntry e, int index) { + none() + } + + /** + * INTERNAL: Do not use. + */ + class Modifier extends @modifier, Ast { + override string toString() { result = "Modifier" } + + /** + * Gets the modifiers of this modifier, if it exists. + */ + string getModifiers() { modifier_modifiers(this, result) } + } + + private Element getImmediateChildOfModifier(Modifier e, int index) { none() } + + /** + * INTERNAL: Do not use. + */ + class OrderElement extends @order_element, Ast { + /** + * Gets the direction of this order element, if it exists. + */ + string getDirection() { order_element_directions(this, result) } + + /** + * Gets the field of this order element, if it exists. + */ + string getField() { order_element_fields(this, result) } + + /** + * Gets the index of this order element, if it exists. + */ + int getIndex() { order_element_indices(this, result) } + } + + /** + * INTERNAL: Do not use. + */ + class Qualifier extends @qualifier, Ast { } + + /** + * INTERNAL: Do not use. + */ + class Query extends @query, Ast { + override string toString() { result = "Query" } + + /** + * Gets the buffer name of this query, if it exists. + */ + string getBufferName() { query_buffer_names(this, result) } + + /** + * Gets the cross company of this query, if it exists. + */ + CrossCompany getCrossCompany() { query_cross_companies(this, result) } + + /** + * Gets the `index`th group by element of this query (0-based). + */ + OrderElement getGroupByElement(int index) { query_group_by_elements(this, index, result) } + + /** + * Gets the number of group by elements of this query. + */ + int getNumberOfGroupByElements() { result = count(int i | query_group_by_elements(this, i, _)) } + + /** + * Gets the index name of this query, if it exists. + */ + string getIndexName() { query_index_names(this, result) } + + /** + * Gets the joins of this query, if it exists. + */ + JoinSpecification getJoins() { query_joins(this, result) } + + /** + * Gets the `index`th order by element of this query (0-based). + */ + OrderElement getOrderByElement(int index) { query_order_by_elements(this, index, result) } + + /** + * Gets the number of order by elements of this query. + */ + int getNumberOfOrderByElements() { result = count(int i | query_order_by_elements(this, i, _)) } + + /** + * Gets the selection of this query, if it exists. + */ + Selection getSelection() { query_selections(this, result) } + + /** + * Gets the `index`th selection hint of this query (0-based). + */ + string getSelectionHint(int index) { query_selection_hints(this, index, result) } + + /** + * Gets the number of selection hints of this query. + */ + int getNumberOfSelectionHints() { result = count(int i | query_selection_hints(this, i, _)) } + + /** + * Holds if this query uses hint. + */ + predicate usesHint() { query_uses_hint(this) } + + /** + * Gets the valid time state of this query, if it exists. + */ + ValidTimeState getValidTimeState() { query_valid_time_states(this, result) } + + /** + * Gets the where of this query, if it exists. + */ + Expression getWhere() { query_wheres(this, result) } + } + + private Element getImmediateChildOfQuery(Query e, int index) { + exists( + int n, int nCrossCompany, int nGroupByElement, int nJoins, int nOrderByElement, + int nSelection, int nValidTimeState, int nWhere + | + n = 0 and + nCrossCompany = n + 1 and + nGroupByElement = nCrossCompany + e.getNumberOfGroupByElements() and + nJoins = nGroupByElement + 1 and + nOrderByElement = nJoins + e.getNumberOfOrderByElements() and + nSelection = nOrderByElement + 1 and + nValidTimeState = nSelection + 1 and + nWhere = nValidTimeState + 1 and + ( + none() + or + index = n and result = e.getCrossCompany() + or + result = e.getGroupByElement(index - nCrossCompany) + or + index = nGroupByElement and result = e.getJoins() + or + result = e.getOrderByElement(index - nJoins) + or + index = nOrderByElement and result = e.getSelection() + or + index = nSelection and result = e.getValidTimeState() + or + index = nValidTimeState and result = e.getWhere() + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class QueryDataSource extends @query_data_source, Ast { + override string toString() { result = "QueryDataSource" } + + /** + * Gets the `index`th data source of this query data source (0-based). + */ + QueryDataSource getDataSource(int index) { query_data_source_data_sources(this, index, result) } + + /** + * Gets the number of data sources of this query data source. + */ + int getNumberOfDataSources() { + result = count(int i | query_data_source_data_sources(this, i, _)) + } + + /** + * Gets the element type name of this query data source, if it exists. + */ + string getElementTypeName() { query_data_source_element_type_names(this, result) } + + /** + * Gets the fetch mode of this query data source, if it exists. + */ + string getFetchMode() { query_data_source_fetch_modes(this, result) } + + /** + * Gets the `index`th field of this query data source (0-based). + */ + string getField(int index) { query_data_source_fields(this, index, result) } + + /** + * Gets the number of fields of this query data source. + */ + int getNumberOfFields() { result = count(int i | query_data_source_fields(this, i, _)) } + + /** + * Holds if this query data source first fast. + */ + predicate firstFast() { query_data_source_first_fast(this) } + + /** + * Holds if this query data source first only. + */ + predicate firstOnly() { query_data_source_first_only(this) } + + /** + * Gets the `index`th group by of this query data source (0-based). + */ + GlobalOrderElement getGroupBy(int index) { query_data_source_group_bies(this, index, result) } + + /** + * Gets the number of group bies of this query data source. + */ + int getNumberOfGroupBies() { result = count(int i | query_data_source_group_bies(this, i, _)) } + + /** + * Gets the `index`th having of this query data source (0-based). + */ + QueryDataSourceHaving getHaving(int index) { + query_data_source_having_prop(this, index, result) + } + + /** + * Gets the number of havings of this query data source. + */ + int getNumberOfHavings() { result = count(int i | query_data_source_having_prop(this, i, _)) } + + /** + * Gets the join mode of this query data source, if it exists. + */ + string getJoinMode() { query_data_source_join_modes(this, result) } + + /** + * Gets the name of this query data source, if it exists. + */ + string getName() { query_data_source_names(this, result) } + + /** + * Gets the `index`th order by of this query data source (0-based). + */ + GlobalOrderElement getOrderBy(int index) { query_data_source_order_bies(this, index, result) } + + /** + * Gets the number of order bies of this query data source. + */ + int getNumberOfOrderBies() { result = count(int i | query_data_source_order_bies(this, i, _)) } + + /** + * Gets the parent data source of this query data source, if it exists. + */ + QueryDataSource getParentDataSource() { query_data_source_parent_data_sources(this, result) } + + /** + * Gets the path contribution of this query data source, if it exists. + */ + string getPathContribution() { query_data_source_path_contributions(this, result) } + + /** + * Gets the `index`th range of this query data source (0-based). + */ + QueryDataSourceRange getRange(int index) { query_data_source_ranges_prop(this, index, result) } + + /** + * Gets the number of ranges of this query data source. + */ + int getNumberOfRanges() { result = count(int i | query_data_source_ranges_prop(this, i, _)) } + + /** + * Gets the `index`th relation of this query data source (0-based). + */ + QueryDataSourceRelation getRelation(int index) { + query_data_source_relations_prop(this, index, result) + } + + /** + * Gets the number of relations of this query data source. + */ + int getNumberOfRelations() { + result = count(int i | query_data_source_relations_prop(this, i, _)) + } + + /** + * Holds if this query data source select with repeatable read. + */ + predicate selectWithRepeatableRead() { query_data_source_select_with_repeatable_read(this) } + + /** + * Gets the table of this query data source, if it exists. + */ + string getTable() { query_data_source_tables(this, result) } + + /** + * Holds if this query data source update. + */ + predicate update() { query_data_source_update(this) } + } + + private Element getImmediateChildOfQueryDataSource(QueryDataSource e, int index) { + exists( + int n, int nDataSource, int nGroupBy, int nHaving, int nOrderBy, int nParentDataSource, + int nRange, int nRelation + | + n = 0 and + nDataSource = n + e.getNumberOfDataSources() and + nGroupBy = nDataSource + e.getNumberOfGroupBies() and + nHaving = nGroupBy + e.getNumberOfHavings() and + nOrderBy = nHaving + e.getNumberOfOrderBies() and + nParentDataSource = nOrderBy + 1 and + nRange = nParentDataSource + e.getNumberOfRanges() and + nRelation = nRange + e.getNumberOfRelations() and + ( + none() + or + result = e.getDataSource(index - n) + or + result = e.getGroupBy(index - nDataSource) + or + result = e.getHaving(index - nGroupBy) + or + result = e.getOrderBy(index - nHaving) + or + index = nOrderBy and result = e.getParentDataSource() + or + result = e.getRange(index - nParentDataSource) + or + result = e.getRelation(index - nRange) + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class QueryDataSourceHaving extends @query_data_source_having, Ast { + override string toString() { result = "QueryDataSourceHaving" } + + /** + * Gets the data source name of this query data source having, if it exists. + */ + string getDataSourceName() { query_data_source_having_data_source_names(this, result) } + + /** + * Gets the selection of this query data source having, if it exists. + */ + SelectionField getSelection() { query_data_source_having_selections(this, result) } + + /** + * Gets the value of this query data source having, if it exists. + */ + string getValue() { query_data_source_having_values(this, result) } + } + + private Element getImmediateChildOfQueryDataSourceHaving(QueryDataSourceHaving e, int index) { + exists(int n, int nSelection | + n = 0 and + nSelection = n + 1 and + ( + none() + or + index = n and result = e.getSelection() + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class QueryDataSourceRange extends @query_data_source_range, Ast { + override string toString() { result = "QueryDataSourceRange" } + + /** + * Gets the field of this query data source range, if it exists. + */ + string getField() { query_data_source_range_fields(this, result) } + + /** + * Gets the value of this query data source range, if it exists. + */ + string getValue() { query_data_source_range_values(this, result) } + } + + private Element getImmediateChildOfQueryDataSourceRange(QueryDataSourceRange e, int index) { + none() + } + + /** + * INTERNAL: Do not use. + */ + class QueryDataSourceRelation extends @query_data_source_relation, Ast { + override string toString() { result = "QueryDataSourceRelation" } + + /** + * Gets the field of this query data source relation, if it exists. + */ + string getField() { query_data_source_relation_fields(this, result) } + + /** + * Gets the join data source of this query data source relation, if it exists. + */ + string getJoinDataSource() { query_data_source_relation_join_data_sources(this, result) } + + /** + * Gets the related field of this query data source relation, if it exists. + */ + string getRelatedField() { query_data_source_relation_related_fields(this, result) } + } + + private Element getImmediateChildOfQueryDataSourceRelation(QueryDataSourceRelation e, int index) { + none() + } + + /** + * INTERNAL: Do not use. + */ + class Selection extends @selection, Ast { } + + /** + * INTERNAL: Do not use. + */ + class SelectionField extends @selection_field, Ast { + /** + * Gets the extension name of this selection field, if it exists. + */ + string getExtensionName() { selection_field_extension_names(this, result) } + + /** + * Gets the field of this selection field, if it exists. + */ + string getField() { selection_field_fields(this, result) } + } + + /** + * INTERNAL: Do not use. + */ + class Statement extends @statement, Ast { + /** + * Gets the comments of this statement, if it exists. + */ + string getComments() { statement_comments(this, result) } + } + + /** + * INTERNAL: Do not use. + */ + class SwitchCase extends @switch_case, Ast { + override string toString() { result = "SwitchCase" } + } + + private Element getImmediateChildOfSwitchCase(SwitchCase e, int index) { none() } + + /** + * INTERNAL: Do not use. + */ + class SwitchStatementCaseEntry extends @switch_statement_case_entry, XppTuple { + override string toString() { result = "SwitchStatementCaseEntry" } + + /** + * Gets the case of this switch statement case entry, if it exists. + */ + Case getCase() { switch_statement_case_entry_cases(this, result) } + + /** + * Gets the `index`th statement of this switch statement case entry (0-based). + */ + Statement getStatement(int index) { + switch_statement_case_entry_statements(this, index, result) + } + + /** + * Gets the number of statements of this switch statement case entry. + */ + int getNumberOfStatements() { + result = count(int i | switch_statement_case_entry_statements(this, i, _)) + } + } + + private Element getImmediateChildOfSwitchStatementCaseEntry(SwitchStatementCaseEntry e, int index) { + exists(int n, int nCase, int nStatement | + n = 0 and + nCase = n + 1 and + nStatement = nCase + e.getNumberOfStatements() and + ( + none() + or + index = n and result = e.getCase() + or + result = e.getStatement(index - nCase) + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class TableFieldReference extends @table_field_reference, Ast { + /** + * Gets the index of this table field reference, if it exists. + */ + Expression getIndex() { table_field_reference_indices(this, result) } + } + + /** + * INTERNAL: Do not use. + */ + class TryStatementCatchEntry extends @try_statement_catch_entry, XppTuple { + override string toString() { result = "TryStatementCatchEntry" } + + /** + * Gets the catch of this try statement catch entry, if it exists. + */ + Catch getCatch() { try_statement_catch_entry_catches(this, result) } + + /** + * Gets the statement of this try statement catch entry, if it exists. + */ + Statement getStatement() { try_statement_catch_entry_statements(this, result) } + } + + private Element getImmediateChildOfTryStatementCatchEntry(TryStatementCatchEntry e, int index) { + exists(int n, int nCatch, int nStatement | + n = 0 and + nCatch = n + 1 and + nStatement = nCatch + 1 and + ( + none() + or + index = n and result = e.getCatch() + or + index = nCatch and result = e.getStatement() + ) + ) + } + + /** + * INTERNAL: Do not use. + * A node that could not be extracted, for example because of a syntax error. + */ + class UnspecifiedElement extends @unspecified_element, ErrorElement { + override string toString() { result = "UnspecifiedElement" } + + /** + * Gets the parent of this unspecified element, if it exists. + */ + Element getParent() { unspecified_element_parents(this, result) } + + /** + * Gets the property of this unspecified element. + */ + string getProperty() { unspecified_elements(this, result, _) } + + /** + * Gets the index of this unspecified element, if it exists. + */ + int getIndex() { unspecified_element_indices(this, result) } + + /** + * Gets the error of this unspecified element. + */ + string getError() { unspecified_elements(this, _, result) } + } + + private Element getImmediateChildOfUnspecifiedElement(UnspecifiedElement e, int index) { none() } + + /** + * INTERNAL: Do not use. + */ + class ValidTimeState extends @valid_time_state, Ast { } + + /** + * INTERNAL: Do not use. + */ + class XppType extends @xpp_type, Ast { + /** + * Gets the element type name of this xpp type, if it exists. + */ + string getElementTypeName() { xpp_type_element_type_names(this, result) } + + /** + * Holds if this xpp type is obsolete. + */ + predicate isObsolete() { xpp_type_is_obsolete(this) } + } + + /** + * INTERNAL: Do not use. + */ + class AggregateSelection extends @aggregate_selection, SelectionField { } + + /** + * INTERNAL: Do not use. + */ + class AllFieldsSelection extends @all_fields_selection, Selection { + override string toString() { result = "AllFieldsSelection" } + } + + private Element getImmediateChildOfAllFieldsSelection(AllFieldsSelection e, int index) { none() } + + /** + * INTERNAL: Do not use. + */ + class AnyType extends @any_type, XppType { + override string toString() { result = "AnyType" } + } + + private Element getImmediateChildOfAnyType(AnyType e, int index) { none() } + + /** + * INTERNAL: Do not use. + */ + class AssignmentStatement extends @assignment_statement, Statement { } + + /** + * INTERNAL: Do not use. + */ + class BinaryExpression extends @binary_expression, Expression { + /** + * Gets the left of this binary expression, if it exists. + */ + Expression getLeft() { binary_expression_lefts(this, result) } + + /** + * Gets the right of this binary expression, if it exists. + */ + Expression getRight() { binary_expression_rights(this, result) } + } + + /** + * INTERNAL: Do not use. + */ + class BooleanType extends @boolean_type, XppType { + override string toString() { result = "BooleanType" } + } + + private Element getImmediateChildOfBooleanType(BooleanType e, int index) { none() } + + /** + * INTERNAL: Do not use. + */ + class BreakStatement extends @break_statement, Statement { + override string toString() { result = "BreakStatement" } + } + + private Element getImmediateChildOfBreakStatement(BreakStatement e, int index) { none() } + + /** + * INTERNAL: Do not use. + */ + class BreakpointStatement extends @breakpoint_statement, Statement { + override string toString() { result = "BreakpointStatement" } + } + + private Element getImmediateChildOfBreakpointStatement(BreakpointStatement e, int index) { + none() + } + + /** + * INTERNAL: Do not use. + */ + class CaseDefault extends @case_default, Case { + override string toString() { result = "CaseDefault" } + } + + private Element getImmediateChildOfCaseDefault(CaseDefault e, int index) { none() } + + /** + * INTERNAL: Do not use. + */ + class CaseValues extends @case_values, Case { + override string toString() { result = "CaseValues" } + + /** + * Gets the `index`th value of this case values (0-based). + */ + Expression getValue(int index) { case_values_values(this, index, result) } + + /** + * Gets the number of values of this case values. + */ + int getNumberOfValues() { result = count(int i | case_values_values(this, i, _)) } + } + + private Element getImmediateChildOfCaseValues(CaseValues e, int index) { + exists(int n, int nValue | + n = 0 and + nValue = n + e.getNumberOfValues() and + ( + none() + or + result = e.getValue(index - n) + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class CatchAllValues extends @catch_all_values, Catch { + override string toString() { result = "CatchAllValues" } + } + + private Element getImmediateChildOfCatchAllValues(CatchAllValues e, int index) { none() } + + /** + * INTERNAL: Do not use. + */ + class CatchExpression extends @catch_expression, Catch { + override string toString() { result = "CatchExpression" } + + /** + * Gets the expression of this catch expression, if it exists. + */ + Expression getExpression() { catch_expression_expressions(this, result) } + } + + private Element getImmediateChildOfCatchExpression(CatchExpression e, int index) { + exists(int n, int nExpression | + n = 0 and + nExpression = n + 1 and + ( + none() + or + index = n and result = e.getExpression() + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class CatchUpdateConflict extends @catch_update_conflict, Catch { + override string toString() { result = "CatchUpdateConflict" } + + /** + * Gets the expression of this catch update conflict, if it exists. + */ + Expression getExpression() { catch_update_conflict_expressions(this, result) } + + /** + * Gets the instance of this catch update conflict, if it exists. + */ + InstanceName getInstance() { catch_update_conflict_instances(this, result) } + } + + private Element getImmediateChildOfCatchUpdateConflict(CatchUpdateConflict e, int index) { + exists(int n, int nExpression, int nInstance | + n = 0 and + nExpression = n + 1 and + nInstance = nExpression + 1 and + ( + none() + or + index = n and result = e.getExpression() + or + index = nExpression and result = e.getInstance() + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class ChangeStatement extends @change_statement, Statement { + /** + * Gets the expression of this change statement, if it exists. + */ + Expression getExpression() { change_statement_expressions(this, result) } + + /** + * Gets the statement of this change statement, if it exists. + */ + Statement getStatement() { change_statement_statements(this, result) } + } + + /** + * INTERNAL: Do not use. + */ + class CompoundStatement extends @compound_statement, Statement { + override string toString() { result = "CompoundStatement" } + + /** + * Gets the `index`th content of this compound statement (0-based). + */ + Statement getContent(int index) { compound_statement_contents(this, index, result) } + + /** + * Gets the number of contents of this compound statement. + */ + int getNumberOfContents() { result = count(int i | compound_statement_contents(this, i, _)) } + } + + private Element getImmediateChildOfCompoundStatement(CompoundStatement e, int index) { + exists(int n, int nContent | + n = 0 and + nContent = n + e.getNumberOfContents() and + ( + none() + or + result = e.getContent(index - n) + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class ConditionalExpression extends @conditional_expression, Expression { + override string toString() { result = "ConditionalExpression" } + + /** + * Gets the condition of this conditional expression, if it exists. + */ + Expression getCondition() { conditional_expression_conditions(this, result) } + + /** + * Gets the else part of this conditional expression, if it exists. + */ + Expression getElsePart() { conditional_expression_else_parts(this, result) } + + /** + * Gets the if part of this conditional expression, if it exists. + */ + Expression getIfPart() { conditional_expression_if_parts(this, result) } + } + + private Element getImmediateChildOfConditionalExpression(ConditionalExpression e, int index) { + exists(int n, int nTransformation, int nCondition, int nElsePart, int nIfPart | + n = 0 and + nTransformation = n + 1 and + nCondition = nTransformation + 1 and + nElsePart = nCondition + 1 and + nIfPart = nElsePart + 1 and + ( + none() + or + index = n and result = e.getTransformation() + or + index = nTransformation and result = e.getCondition() + or + index = nCondition and result = e.getElsePart() + or + index = nElsePart and result = e.getIfPart() + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class ContainerAttributeLiteral extends @container_attribute_literal, AttributeLiteral { + override string toString() { result = "ContainerAttributeLiteral" } + + /** + * Gets the `index`th value of this container attribute literal (0-based). + */ + AttributeExpression getValue(int index) { + container_attribute_literal_values(this, index, result) + } + + /** + * Gets the number of values of this container attribute literal. + */ + int getNumberOfValues() { + result = count(int i | container_attribute_literal_values(this, i, _)) + } + } + + private Element getImmediateChildOfContainerAttributeLiteral( + ContainerAttributeLiteral e, int index + ) { + exists(int n, int nValue | + n = 0 and + nValue = n + e.getNumberOfValues() and + ( + none() + or + result = e.getValue(index - n) + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class ContainerType extends @container_type, XppType { + override string toString() { result = "ContainerType" } + } + + private Element getImmediateChildOfContainerType(ContainerType e, int index) { none() } + + /** + * INTERNAL: Do not use. + */ + class ContinueStatement extends @continue_statement, Statement { + override string toString() { result = "ContinueStatement" } + } + + private Element getImmediateChildOfContinueStatement(ContinueStatement e, int index) { none() } + + /** + * INTERNAL: Do not use. + */ + class CrossCompanyAll extends @cross_company_all, CrossCompany { + override string toString() { result = "CrossCompanyAll" } + } + + private Element getImmediateChildOfCrossCompanyAll(CrossCompanyAll e, int index) { none() } + + /** + * INTERNAL: Do not use. + */ + class CrossCompanyContainer extends @cross_company_container, CrossCompany { + override string toString() { result = "CrossCompanyContainer" } + + /** + * Gets the container of this cross company container, if it exists. + */ + Expression getContainer() { cross_company_container_containers(this, result) } + } + + private Element getImmediateChildOfCrossCompanyContainer(CrossCompanyContainer e, int index) { + exists(int n, int nContainer | + n = 0 and + nContainer = n + 1 and + ( + none() + or + index = n and result = e.getContainer() + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class DateTimeType extends @date_time_type, XppType { + override string toString() { result = "DateTimeType" } + } + + private Element getImmediateChildOfDateTimeType(DateTimeType e, int index) { none() } + + /** + * INTERNAL: Do not use. + */ + class DateType extends @date_type, XppType { + override string toString() { result = "DateType" } + } + + private Element getImmediateChildOfDateType(DateType e, int index) { none() } + + /** + * INTERNAL: Do not use. + */ + class DblType extends @dbl_type, XppType { + override string toString() { result = "DblType" } + } + + private Element getImmediateChildOfDblType(DblType e, int index) { none() } + + /** + * INTERNAL: Do not use. + */ + class Declaration extends @declaration, CompilationUnit { + /** + * Gets the array specification of this declaration, if it exists. + */ + ArraySpecification getArraySpecification() { declaration_array_specifications(this, result) } + + /** + * Gets the `index`th modifier list of this declaration (0-based). + */ + Modifier getModifierList(int index) { declaration_modifier_lists(this, index, result) } + + /** + * Gets the number of modifier lists of this declaration. + */ + int getNumberOfModifierLists() { + result = count(int i | declaration_modifier_lists(this, i, _)) + } + + /** + * Gets the modifiers of this declaration, if it exists. + */ + string getModifiers() { declaration_modifiers(this, result) } + + /** + * Gets the type of this declaration, if it exists. + */ + XppType getType() { declaration_types(this, result) } + } + + /** + * INTERNAL: Do not use. + */ + class DefaultTypeAttributeLiteral extends @default_type_attribute_literal, AttributeLiteral { + /** + * Gets the scanned literal value of this default type attribute literal, if it exists. + */ + string getScannedLiteralValue() { + default_type_attribute_literal_scanned_literal_values(this, result) + } + } + + /** + * INTERNAL: Do not use. + */ + class DeleteStatement extends @delete_statement, Statement { + override string toString() { result = "DeleteStatement" } + + /** + * Gets the query of this delete statement, if it exists. + */ + Query getQuery() { delete_statement_queries(this, result) } + } + + private Element getImmediateChildOfDeleteStatement(DeleteStatement e, int index) { + exists(int n, int nQuery | + n = 0 and + nQuery = n + 1 and + ( + none() + or + index = n and result = e.getQuery() + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class DoWhileStatement extends @do_while_statement, Statement { + override string toString() { result = "DoWhileStatement" } + + /** + * Gets the condition of this do while statement, if it exists. + */ + Expression getCondition() { do_while_statement_conditions(this, result) } + + /** + * Gets the statement of this do while statement, if it exists. + */ + Statement getStatement() { do_while_statement_statements(this, result) } + } + + private Element getImmediateChildOfDoWhileStatement(DoWhileStatement e, int index) { + exists(int n, int nCondition, int nStatement | + n = 0 and + nCondition = n + 1 and + nStatement = nCondition + 1 and + ( + none() + or + index = n and result = e.getCondition() + or + index = nCondition and result = e.getStatement() + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class EmptyExpression extends @empty_expression, Expression { + override string toString() { result = "EmptyExpression" } + } + + private Element getImmediateChildOfEmptyExpression(EmptyExpression e, int index) { + exists(int n, int nTransformation | + n = 0 and + nTransformation = n + 1 and + ( + none() + or + index = n and result = e.getTransformation() + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class EmptyStatement extends @empty_statement, Statement { + override string toString() { result = "EmptyStatement" } + } + + private Element getImmediateChildOfEmptyStatement(EmptyStatement e, int index) { none() } + + /** + * INTERNAL: Do not use. + */ + class EnumAttributeLiteral extends @enum_attribute_literal, AttributeLiteral { + override string toString() { result = "EnumAttributeLiteral" } + + /** + * Gets the literal of this enum attribute literal, if it exists. + */ + string getLiteral() { enum_attribute_literal_literals(this, result) } + + /** + * Gets the type name of this enum attribute literal, if it exists. + */ + string getTypeName() { enum_attribute_literal_type_names(this, result) } + } + + private Element getImmediateChildOfEnumAttributeLiteral(EnumAttributeLiteral e, int index) { + none() + } + + /** + * INTERNAL: Do not use. + */ + class EnumerationType extends @enumeration_type, XppType { + override string toString() { result = "EnumerationType" } + + /** + * Gets the enumerated type of this enumeration type, if it exists. + */ + string getEnumeratedType() { enumeration_type_enumerated_types(this, result) } + + /** + * Gets the full name of this enumeration type, if it exists. + */ + string getFullName() { enumeration_type_full_names(this, result) } + + /** + * Gets the namespace of this enumeration type, if it exists. + */ + string getNamespace() { enumeration_type_namespaces(this, result) } + } + + private Element getImmediateChildOfEnumerationType(EnumerationType e, int index) { none() } + + /** + * INTERNAL: Do not use. + */ + class Evaluation extends @evaluation, Expression { + /** + * Gets the `index`th actual parameter of this evaluation (0-based). + */ + EvaluationActualParameterEntry getActualParameter(int index) { + evaluation_actual_parameters(this, index, result) + } + + /** + * Gets the number of actual parameters of this evaluation. + */ + int getNumberOfActualParameters() { + result = count(int i | evaluation_actual_parameters(this, i, _)) + } + } + + /** + * INTERNAL: Do not use. + */ + class ExplicitSelection extends @explicit_selection, Selection { + override string toString() { result = "ExplicitSelection" } + + /** + * Gets the `index`th field of this explicit selection (0-based). + */ + SelectionField getField(int index) { explicit_selection_fields(this, index, result) } + + /** + * Gets the number of fields of this explicit selection. + */ + int getNumberOfFields() { result = count(int i | explicit_selection_fields(this, i, _)) } + } + + private Element getImmediateChildOfExplicitSelection(ExplicitSelection e, int index) { + exists(int n, int nField | + n = 0 and + nField = n + e.getNumberOfFields() and + ( + none() + or + result = e.getField(index - n) + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class ExpressionCompilationUnit extends @expression_compilation_unit, CompilationUnit { + override string toString() { result = "ExpressionCompilationUnit" } + + /** + * Gets the expression of this expression compilation unit, if it exists. + */ + Expression getExpression() { expression_compilation_unit_expressions(this, result) } + + /** + * Gets the path contribution of this expression compilation unit, if it exists. + */ + string getPathContribution() { expression_compilation_unit_path_contributions(this, result) } + } + + private Element getImmediateChildOfExpressionCompilationUnit( + ExpressionCompilationUnit e, int index + ) { + exists(int n, int nComments, int nRegion, int nExpression | + n = 0 and + nComments = n + 1 and + nRegion = nComments + e.getNumberOfRegions() and + nExpression = nRegion + 1 and + ( + none() + or + index = n and result = e.getComments() + or + result = e.getRegion(index - nComments) + or + index = nRegion and result = e.getExpression() + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class ExpressionQualifier extends @expression_qualifier, Qualifier { + override string toString() { result = "ExpressionQualifier" } + + /** + * Gets the expression of this expression qualifier, if it exists. + */ + Expression getExpression() { expression_qualifier_expressions(this, result) } + } + + private Element getImmediateChildOfExpressionQualifier(ExpressionQualifier e, int index) { + exists(int n, int nExpression | + n = 0 and + nExpression = n + 1 and + ( + none() + or + index = n and result = e.getExpression() + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class ExpressionStatement extends @expression_statement, Statement { + override string toString() { result = "ExpressionStatement" } + + /** + * Gets the element type name of this expression statement, if it exists. + */ + string getElementTypeName() { expression_statement_element_type_names(this, result) } + + /** + * Gets the expression of this expression statement, if it exists. + */ + Expression getExpression() { expression_statement_expressions(this, result) } + } + + private Element getImmediateChildOfExpressionStatement(ExpressionStatement e, int index) { + exists(int n, int nExpression | + n = 0 and + nExpression = n + 1 and + ( + none() + or + index = n and result = e.getExpression() + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class FieldExpression extends @field_expression, Expression { + /** + * Gets the field of this field expression, if it exists. + */ + FieldSpecification getField() { field_expression_fields(this, result) } + + /** + * Holds if this field expression is enum. + */ + predicate isEnum() { field_expression_is_enum(this) } + } + + /** + * INTERNAL: Do not use. + */ + class FieldSelection extends @field_selection, SelectionField { + override string toString() { result = "FieldSelection" } + + /** + * Gets the index of this field selection, if it exists. + */ + int getIndex() { field_selection_indices(this, result) } + } + + private Element getImmediateChildOfFieldSelection(FieldSelection e, int index) { none() } + + /** + * INTERNAL: Do not use. + */ + class FindStatement extends @find_statement, Statement { + override string toString() { result = "FindStatement" } + + /** + * Gets the query of this find statement, if it exists. + */ + Query getQuery() { find_statement_queries(this, result) } + } + + private Element getImmediateChildOfFindStatement(FindStatement e, int index) { + exists(int n, int nQuery | + n = 0 and + nQuery = n + 1 and + ( + none() + or + index = n and result = e.getQuery() + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class FlushStatement extends @flush_statement, Statement { + override string toString() { result = "FlushStatement" } + + /** + * Gets the `index`th id list of this flush statement (0-based). + */ + string getIdList(int index) { flush_statement_id_lists(this, index, result) } + + /** + * Gets the number of id lists of this flush statement. + */ + int getNumberOfIdLists() { result = count(int i | flush_statement_id_lists(this, i, _)) } + } + + private Element getImmediateChildOfFlushStatement(FlushStatement e, int index) { none() } + + /** + * INTERNAL: Do not use. + */ + class ForDeclarationAssign extends @for_declaration_assign, ForAssign { + override string toString() { result = "ForDeclarationAssign" } + + /** + * Gets the `index`th initialization declaration of this for declaration assign (0-based). + */ + VariableDeclaration getInitializationDeclaration(int index) { + for_declaration_assign_initialization_declarations(this, index, result) + } + + /** + * Gets the number of initialization declarations of this for declaration assign. + */ + int getNumberOfInitializationDeclarations() { + result = count(int i | for_declaration_assign_initialization_declarations(this, i, _)) + } + } + + private Element getImmediateChildOfForDeclarationAssign(ForDeclarationAssign e, int index) { + exists(int n, int nFieldSpecification, int nInitializationDeclaration | + n = 0 and + nFieldSpecification = n + 1 and + nInitializationDeclaration = nFieldSpecification + e.getNumberOfInitializationDeclarations() and + ( + none() + or + index = n and result = e.getFieldSpecification() + or + result = e.getInitializationDeclaration(index - nFieldSpecification) + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class ForExpressionAssign extends @for_expression_assign, ForAssign { + /** + * Gets the expression of this for expression assign, if it exists. + */ + Expression getExpression() { for_expression_assign_expressions(this, result) } + } + + /** + * INTERNAL: Do not use. + */ + class ForFieldPostDecrement extends @for_field_post_decrement, ForAssign { + override string toString() { result = "ForFieldPostDecrement" } + } + + private Element getImmediateChildOfForFieldPostDecrement(ForFieldPostDecrement e, int index) { + exists(int n, int nFieldSpecification | + n = 0 and + nFieldSpecification = n + 1 and + ( + none() + or + index = n and result = e.getFieldSpecification() + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class ForFieldPostIncrement extends @for_field_post_increment, ForAssign { + override string toString() { result = "ForFieldPostIncrement" } + } + + private Element getImmediateChildOfForFieldPostIncrement(ForFieldPostIncrement e, int index) { + exists(int n, int nFieldSpecification | + n = 0 and + nFieldSpecification = n + 1 and + ( + none() + or + index = n and result = e.getFieldSpecification() + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class ForFieldPreDecrement extends @for_field_pre_decrement, ForAssign { + override string toString() { result = "ForFieldPreDecrement" } + } + + private Element getImmediateChildOfForFieldPreDecrement(ForFieldPreDecrement e, int index) { + exists(int n, int nFieldSpecification | + n = 0 and + nFieldSpecification = n + 1 and + ( + none() + or + index = n and result = e.getFieldSpecification() + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class ForFieldPreIncrement extends @for_field_pre_increment, ForAssign { + override string toString() { result = "ForFieldPreIncrement" } + } + + private Element getImmediateChildOfForFieldPreIncrement(ForFieldPreIncrement e, int index) { + exists(int n, int nFieldSpecification | + n = 0 and + nFieldSpecification = n + 1 and + ( + none() + or + index = n and result = e.getFieldSpecification() + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class ForStatement extends @for_statement, Statement { + override string toString() { result = "ForStatement" } + + /** + * Gets the condition of this for statement, if it exists. + */ + Expression getCondition() { for_statement_conditions(this, result) } + + /** + * Gets the initialization of this for statement, if it exists. + */ + ForAssign getInitialization() { for_statement_initializations(this, result) } + + /** + * Gets the statement of this for statement, if it exists. + */ + Statement getStatement() { for_statement_statements(this, result) } + + /** + * Gets the update of this for statement, if it exists. + */ + ForAssign getUpdate() { for_statement_updates(this, result) } + } + + private Element getImmediateChildOfForStatement(ForStatement e, int index) { + exists(int n, int nCondition, int nInitialization, int nStatement, int nUpdate | + n = 0 and + nCondition = n + 1 and + nInitialization = nCondition + 1 and + nStatement = nInitialization + 1 and + nUpdate = nStatement + 1 and + ( + none() + or + index = n and result = e.getCondition() + or + index = nCondition and result = e.getInitialization() + or + index = nInitialization and result = e.getStatement() + or + index = nStatement and result = e.getUpdate() + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class GenericXppType extends @generic_xpp_type, XppType { + /** + * Gets the `index`th type argument list of this generic xpp type (0-based). + */ + XppType getTypeArgumentList(int index) { + generic_xpp_type_type_argument_lists(this, index, result) + } + + /** + * Gets the number of type argument lists of this generic xpp type. + */ + int getNumberOfTypeArgumentLists() { + result = count(int i | generic_xpp_type_type_argument_lists(this, i, _)) + } + } + + /** + * INTERNAL: Do not use. + */ + class GlobalOrderElement extends @global_order_element, OrderElement { + override string toString() { result = "GlobalOrderElement" } + + /** + * Gets the extension name of this global order element, if it exists. + */ + string getExtensionName() { global_order_element_extension_names(this, result) } + + /** + * Gets the table of this global order element, if it exists. + */ + string getTable() { global_order_element_tables(this, result) } + } + + private Element getImmediateChildOfGlobalOrderElement(GlobalOrderElement e, int index) { none() } + + /** + * INTERNAL: Do not use. + */ + class GuidType extends @guid_type, XppType { + override string toString() { result = "GuidType" } + } + + private Element getImmediateChildOfGuidType(GuidType e, int index) { none() } + + /** + * INTERNAL: Do not use. + */ + class IfStatement extends @if_statement, Statement { + override string toString() { result = "IfStatement" } + + /** + * Gets the condition of this if statement, if it exists. + */ + Expression getCondition() { if_statement_conditions(this, result) } + + /** + * Gets the consequent of this if statement, if it exists. + */ + Statement getConsequent() { if_statement_consequents(this, result) } + } + + private Element getImmediateChildOfIfStatement(IfStatement e, int index) { + exists(int n, int nCondition, int nConsequent | + n = 0 and + nCondition = n + 1 and + nConsequent = nCondition + 1 and + ( + none() + or + index = n and result = e.getCondition() + or + index = nCondition and result = e.getConsequent() + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class IfThenElseStatement extends @if_then_else_statement, Statement { + override string toString() { result = "IfThenElseStatement" } + + /** + * Gets the antecedent of this if then else statement, if it exists. + */ + Statement getAntecedent() { if_then_else_statement_antecedents(this, result) } + + /** + * Gets the condition of this if then else statement, if it exists. + */ + Expression getCondition() { if_then_else_statement_conditions(this, result) } + + /** + * Gets the consequent of this if then else statement, if it exists. + */ + Statement getConsequent() { if_then_else_statement_consequents(this, result) } + } + + private Element getImmediateChildOfIfThenElseStatement(IfThenElseStatement e, int index) { + exists(int n, int nAntecedent, int nCondition, int nConsequent | + n = 0 and + nAntecedent = n + 1 and + nCondition = nAntecedent + 1 and + nConsequent = nCondition + 1 and + ( + none() + or + index = n and result = e.getAntecedent() + or + index = nAntecedent and result = e.getCondition() + or + index = nCondition and result = e.getConsequent() + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class ImplicitSelection extends @implicit_selection, Selection { + override string toString() { result = "ImplicitSelection" } + } + + private Element getImmediateChildOfImplicitSelection(ImplicitSelection e, int index) { none() } + + /** + * INTERNAL: Do not use. + */ + class InsertStatement extends @insert_statement, Statement { + override string toString() { result = "InsertStatement" } + + /** + * Gets the cross company of this insert statement, if it exists. + */ + CrossCompany getCrossCompany() { insert_statement_cross_companies(this, result) } + + /** + * Gets the `index`th field of this insert statement (0-based). + */ + InsertFieldSpecification getField(int index) { insert_statement_fields(this, index, result) } + + /** + * Gets the number of fields of this insert statement. + */ + int getNumberOfFields() { result = count(int i | insert_statement_fields(this, i, _)) } + + /** + * Gets the query of this insert statement, if it exists. + */ + Query getQuery() { insert_statement_queries(this, result) } + + /** + * Gets the table of this insert statement, if it exists. + */ + string getTable() { insert_statement_tables(this, result) } + } + + private Element getImmediateChildOfInsertStatement(InsertStatement e, int index) { + exists(int n, int nCrossCompany, int nField, int nQuery | + n = 0 and + nCrossCompany = n + 1 and + nField = nCrossCompany + e.getNumberOfFields() and + nQuery = nField + 1 and + ( + none() + or + index = n and result = e.getCrossCompany() + or + result = e.getField(index - nCrossCompany) + or + index = nField and result = e.getQuery() + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class Int64Type extends @int64_type, XppType { + override string toString() { result = "Int64Type" } + } + + private Element getImmediateChildOfInt64Type(Int64Type e, int index) { none() } + + /** + * INTERNAL: Do not use. + */ + class IntType extends @int_type, XppType { + override string toString() { result = "IntType" } + } + + private Element getImmediateChildOfIntType(IntType e, int index) { none() } + + /** + * INTERNAL: Do not use. + */ + class Intrinsic extends @intrinsic, Expression { + override string toString() { result = "Intrinsic" } + + /** + * Gets the arg1 of this intrinsic, if it exists. + */ + string getArg1() { intrinsic_arg1s(this, result) } + + /** + * Gets the arg2 of this intrinsic, if it exists. + */ + string getArg2() { intrinsic_arg2s(this, result) } + + /** + * Gets the arg3 of this intrinsic, if it exists. + */ + string getArg3() { intrinsic_arg3s(this, result) } + + /** + * Gets the name of this intrinsic, if it exists. + */ + string getName() { intrinsic_names(this, result) } + } + + private Element getImmediateChildOfIntrinsic(Intrinsic e, int index) { + exists(int n, int nTransformation | + n = 0 and + nTransformation = n + 1 and + ( + none() + or + index = n and result = e.getTransformation() + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class IntrinsicAttributeLiteral extends @intrinsic_attribute_literal, AttributeLiteral { + override string toString() { result = "IntrinsicAttributeLiteral" } + + /** + * Gets the arg1 of this intrinsic attribute literal, if it exists. + */ + string getArg1() { intrinsic_attribute_literal_arg1s(this, result) } + + /** + * Gets the arg2 of this intrinsic attribute literal, if it exists. + */ + string getArg2() { intrinsic_attribute_literal_arg2s(this, result) } + + /** + * Gets the arg3 of this intrinsic attribute literal, if it exists. + */ + string getArg3() { intrinsic_attribute_literal_arg3s(this, result) } + + /** + * Gets the function name of this intrinsic attribute literal, if it exists. + */ + string getFunctionName() { intrinsic_attribute_literal_function_names(this, result) } + } + + private Element getImmediateChildOfIntrinsicAttributeLiteral( + IntrinsicAttributeLiteral e, int index + ) { + none() + } + + /** + * INTERNAL: Do not use. + */ + class IsAsExpression extends @is_as_expression, Expression { + /** + * Gets the expression of this is as expression, if it exists. + */ + Expression getExpression() { is_as_expression_expressions(this, result) } + + /** + * Gets the type name of this is as expression, if it exists. + */ + string getTypeName() { is_as_expression_type_names(this, result) } + } + + /** + * INTERNAL: Do not use. + */ + class LiteralExpression extends @literal_expression, Expression { } + + /** + * INTERNAL: Do not use. + */ + class LocalDeclarationsStatement extends @local_declarations_statement, Statement { + override string toString() { result = "LocalDeclarationsStatement" } + + /** + * Gets the `index`th declaration of this local declarations statement (0-based). + */ + LocalDeclaration getDeclaration(int index) { + local_declarations_statement_declarations(this, index, result) + } + + /** + * Gets the number of declarations of this local declarations statement. + */ + int getNumberOfDeclarations() { + result = count(int i | local_declarations_statement_declarations(this, i, _)) + } + } + + private Element getImmediateChildOfLocalDeclarationsStatement( + LocalDeclarationsStatement e, int index + ) { + exists(int n, int nDeclaration | + n = 0 and + nDeclaration = n + e.getNumberOfDeclarations() and + ( + none() + or + result = e.getDeclaration(index - n) + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class MethodOrDelegate extends @method_or_delegate, CompilationUnit { + /** + * Gets the attributes of this method or delegate, if it exists. + */ + AttributeList getAttributes() { method_or_delegate_attributes(this, result) } + + /** + * Gets the `index`th modifier list of this method or delegate (0-based). + */ + Modifier getModifierList(int index) { method_or_delegate_modifier_lists(this, index, result) } + + /** + * Gets the number of modifier lists of this method or delegate. + */ + int getNumberOfModifierLists() { + result = count(int i | method_or_delegate_modifier_lists(this, i, _)) + } + + /** + * Gets the `index`th parameter of this method or delegate (0-based). + */ + ParameterDeclaration getParameter(int index) { + method_or_delegate_parameters(this, index, result) + } + + /** + * Gets the number of parameters of this method or delegate. + */ + int getNumberOfParameters() { + result = count(int i | method_or_delegate_parameters(this, i, _)) + } + + /** + * Gets the path contribution of this method or delegate, if it exists. + */ + string getPathContribution() { method_or_delegate_path_contributions(this, result) } + + /** + * Gets the type of this method or delegate, if it exists. + */ + XppType getType() { method_or_delegate_types(this, result) } + + /** + * Gets the `index`th type parameter of this method or delegate (0-based). + */ + string getTypeParameter(int index) { method_or_delegate_type_parameters(this, index, result) } + + /** + * Gets the number of type parameters of this method or delegate. + */ + int getNumberOfTypeParameters() { + result = count(int i | method_or_delegate_type_parameters(this, i, _)) + } + } + + /** + * INTERNAL: Do not use. + */ + class ModelElement extends @model_element, CompilationUnit { + /** + * Gets the `index`th base method of this model element (0-based). + */ + MethodOrDelegate getBaseMethod(int index) { model_element_base_methods(this, index, result) } + + /** + * Gets the number of base methods of this model element. + */ + int getNumberOfBaseMethods() { result = count(int i | model_element_base_methods(this, i, _)) } + + /** + * Gets the `index`th extend generic parameter of this model element (0-based). + */ + XppType getExtendGenericParameter(int index) { + model_element_extend_generic_parameters(this, index, result) + } + + /** + * Gets the number of extend generic parameters of this model element. + */ + int getNumberOfExtendGenericParameters() { + result = count(int i | model_element_extend_generic_parameters(this, i, _)) + } + + /** + * Gets the full name of this model element, if it exists. + */ + string getFullName() { model_element_full_names(this, result) } + + /** + * Gets the full name no default namespace of this model element, if it exists. + */ + string getFullNameNoDefaultNamespace() { + model_element_full_name_no_default_namespaces(this, result) + } + + /** + * Holds if this model element is internal. + */ + predicate isInternal() { model_element_is_internal(this) } + + /** + * Holds if this model element is kernel. + */ + predicate isKernel() { model_element_is_kernel(this) } + + /** + * Holds if this model element is obsolete. + */ + predicate isObsolete() { model_element_is_obsolete(this) } + + /** + * Holds if this model element is private. + */ + predicate isPrivate() { model_element_is_private(this) } + + /** + * Holds if this model element is public. + */ + predicate isPublic() { model_element_is_public(this) } + + /** + * Gets the `index`th method of this model element (0-based). + */ + MethodOrDelegate getMethod(int index) { model_element_methods(this, index, result) } + + /** + * Gets the number of methods of this model element. + */ + int getNumberOfMethods() { result = count(int i | model_element_methods(this, i, _)) } + + /** + * Gets the model of this model element, if it exists. + */ + int getModelId() { model_element_model_ids(this, result) } + + /** + * Gets the `index`th modifier list of this model element (0-based). + */ + ClassAccessModifier getModifierList(int index) { + model_element_modifier_lists(this, index, result) + } + + /** + * Gets the number of modifier lists of this model element. + */ + int getNumberOfModifierLists() { + result = count(int i | model_element_modifier_lists(this, i, _)) + } + + /** + * Gets the modifiers of this model element, if it exists. + */ + string getModifiers() { model_element_modifiers(this, result) } + + /** + * Gets the namespace of this model element, if it exists. + */ + string getNamespace() { model_element_namespaces(this, result) } + + /** + * Gets the `index`th nested class of this model element (0-based). + */ + ClassOrInterface getNestedClass(int index) { model_element_nested_classes(this, index, result) } + + /** + * Gets the number of nested classes of this model element. + */ + int getNumberOfNestedClasses() { + result = count(int i | model_element_nested_classes(this, i, _)) + } + + /** + * Gets the path contribution of this model element, if it exists. + */ + string getPathContribution() { model_element_path_contributions(this, result) } + + /** + * Gets the `index`th type parameter of this model element (0-based). + */ + string getTypeParameter(int index) { model_element_type_parameters(this, index, result) } + + /** + * Gets the number of type parameters of this model element. + */ + int getNumberOfTypeParameters() { + result = count(int i | model_element_type_parameters(this, i, _)) + } + + /** + * Gets the `index`th using of this model element (0-based). + */ + ModelElementUsingEntry getUsing(int index) { model_element_usings(this, index, result) } + + /** + * Gets the number of usings of this model element. + */ + int getNumberOfUsings() { result = count(int i | model_element_usings(this, i, _)) } + + /** + * Gets the visibility of this model element, if it exists. + */ + string getVisibility() { model_element_visibilities(this, result) } + } + + /** + * INTERNAL: Do not use. + */ + class MoveCursorStatement extends @move_cursor_statement, Statement { + override string toString() { result = "MoveCursorStatement" } + + /** + * Gets the selection of this move cursor statement, if it exists. + */ + Selection getSelection() { move_cursor_statement_selections(this, result) } + + /** + * Gets the table of this move cursor statement, if it exists. + */ + string getTable() { move_cursor_statement_tables(this, result) } + } + + private Element getImmediateChildOfMoveCursorStatement(MoveCursorStatement e, int index) { + exists(int n, int nSelection | + n = 0 and + nSelection = n + 1 and + ( + none() + or + index = n and result = e.getSelection() + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class NamedFieldReference extends @named_field_reference, TableFieldReference { + override string toString() { result = "NamedFieldReference" } + + /** + * Gets the extension name of this named field reference, if it exists. + */ + string getExtensionName() { named_field_reference_extension_names(this, result) } + + /** + * Gets the field name of this named field reference, if it exists. + */ + string getFieldName() { named_field_reference_field_names(this, result) } + } + + private Element getImmediateChildOfNamedFieldReference(NamedFieldReference e, int index) { + exists(int n, int nIndex | + n = 0 and + nIndex = n + 1 and + ( + none() + or + index = n and result = e.getIndex() + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class NewClrArrayExpression extends @new_clr_array_expression, Expression { + override string toString() { result = "NewClrArrayExpression" } + + /** + * Gets the full name of this new clr array expression, if it exists. + */ + string getFullName() { new_clr_array_expression_full_names(this, result) } + + /** + * Gets the `index`th rectangular dimension of this new clr array expression (0-based). + */ + int getRectangularDimension(int index) { + new_clr_array_expression_rectangular_dimensions(this, index, result) + } + + /** + * Gets the number of rectangular dimensions of this new clr array expression. + */ + int getNumberOfRectangularDimensions() { + result = count(int i | new_clr_array_expression_rectangular_dimensions(this, i, _)) + } + + /** + * Gets the `index`th size of this new clr array expression (0-based). + */ + Expression getSize(int index) { new_clr_array_expression_sizes(this, index, result) } + + /** + * Gets the number of sizes of this new clr array expression. + */ + int getNumberOfSizes() { result = count(int i | new_clr_array_expression_sizes(this, i, _)) } + + /** + * Gets the `index`th type argument list of this new clr array expression (0-based). + */ + XppType getTypeArgumentList(int index) { + new_clr_array_expression_type_argument_lists(this, index, result) + } + + /** + * Gets the number of type argument lists of this new clr array expression. + */ + int getNumberOfTypeArgumentLists() { + result = count(int i | new_clr_array_expression_type_argument_lists(this, i, _)) + } + } + + private Element getImmediateChildOfNewClrArrayExpression(NewClrArrayExpression e, int index) { + exists(int n, int nTransformation, int nSize, int nTypeArgumentList | + n = 0 and + nTransformation = n + 1 and + nSize = nTransformation + e.getNumberOfSizes() and + nTypeArgumentList = nSize + e.getNumberOfTypeArgumentLists() and + ( + none() + or + index = n and result = e.getTransformation() + or + result = e.getSize(index - nTransformation) + or + result = e.getTypeArgumentList(index - nSize) + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class NumberedFieldReference extends @numbered_field_reference, TableFieldReference { + override string toString() { result = "NumberedFieldReference" } + + /** + * Gets the field number of this numbered field reference, if it exists. + */ + Expression getFieldNumber() { numbered_field_reference_field_numbers(this, result) } + } + + private Element getImmediateChildOfNumberedFieldReference(NumberedFieldReference e, int index) { + exists(int n, int nIndex, int nFieldNumber | + n = 0 and + nIndex = n + 1 and + nFieldNumber = nIndex + 1 and + ( + none() + or + index = n and result = e.getIndex() + or + index = nIndex and result = e.getFieldNumber() + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class Placeholder extends @placeholder, Expression { + override string toString() { result = "Placeholder" } + } + + private Element getImmediateChildOfPlaceholder(Placeholder e, int index) { + exists(int n, int nTransformation | + n = 0 and + nTransformation = n + 1 and + ( + none() + or + index = n and result = e.getTransformation() + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class PrintStatement extends @print_statement, Statement { + override string toString() { result = "PrintStatement" } + + /** + * Gets the `index`th expression of this print statement (0-based). + */ + Expression getExpression(int index) { print_statement_expressions(this, index, result) } + + /** + * Gets the number of expressions of this print statement. + */ + int getNumberOfExpressions() { result = count(int i | print_statement_expressions(this, i, _)) } + } + + private Element getImmediateChildOfPrintStatement(PrintStatement e, int index) { + exists(int n, int nExpression | + n = 0 and + nExpression = n + e.getNumberOfExpressions() and + ( + none() + or + result = e.getExpression(index - n) + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class ProvidedType extends @provided_type, XppType { + override string toString() { result = "ProvidedType" } + + /** + * Gets the `index`th argument list of this provided type (0-based). + */ + Expression getArgumentList(int index) { provided_type_argument_lists(this, index, result) } + + /** + * Gets the number of argument lists of this provided type. + */ + int getNumberOfArgumentLists() { + result = count(int i | provided_type_argument_lists(this, i, _)) + } + + /** + * Gets the name of this provided type, if it exists. + */ + string getName() { provided_type_names(this, result) } + } + + private Element getImmediateChildOfProvidedType(ProvidedType e, int index) { + exists(int n, int nArgumentList | + n = 0 and + nArgumentList = n + e.getNumberOfArgumentLists() and + ( + none() + or + result = e.getArgumentList(index - n) + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class QualifiedField extends @qualified_field, FieldSpecification { + override string toString() { result = "QualifiedField" } + + /** + * Gets the extension name of this qualified field, if it exists. + */ + string getExtensionName() { qualified_field_extension_names(this, result) } + + /** + * Gets the name of this qualified field, if it exists. + */ + string getName() { qualified_field_names(this, result) } + } + + private Element getImmediateChildOfQualifiedField(QualifiedField e, int index) { + exists(int n, int nArrayIndex, int nQualifier | + n = 0 and + nArrayIndex = n + 1 and + nQualifier = nArrayIndex + 1 and + ( + none() + or + index = n and result = e.getArrayIndex() + or + index = nArrayIndex and result = e.getQualifier() + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class QualifiedInstanceName extends @qualified_instance_name, InstanceName { + override string toString() { result = "QualifiedInstanceName" } + + /** + * Gets the index of this qualified instance name, if it exists. + */ + Expression getIndex() { qualified_instance_name_indices(this, result) } + + /** + * Gets the name of this qualified instance name, if it exists. + */ + string getName() { qualified_instance_name_names(this, result) } + + /** + * Gets the qualifier of this qualified instance name, if it exists. + */ + Qualifier getQualifier() { qualified_instance_name_qualifiers(this, result) } + } + + private Element getImmediateChildOfQualifiedInstanceName(QualifiedInstanceName e, int index) { + exists(int n, int nIndex, int nQualifier | + n = 0 and + nIndex = n + 1 and + nQualifier = nIndex + 1 and + ( + none() + or + index = n and result = e.getIndex() + or + index = nIndex and result = e.getQualifier() + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class QualifiedNumberedField extends @qualified_numbered_field, FieldSpecification { + override string toString() { result = "QualifiedNumberedField" } + + /** + * Gets the field number of this qualified numbered field, if it exists. + */ + Expression getFieldNumber() { qualified_numbered_field_field_numbers(this, result) } + } + + private Element getImmediateChildOfQualifiedNumberedField(QualifiedNumberedField e, int index) { + exists(int n, int nArrayIndex, int nQualifier, int nFieldNumber | + n = 0 and + nArrayIndex = n + 1 and + nQualifier = nArrayIndex + 1 and + nFieldNumber = nQualifier + 1 and + ( + none() + or + index = n and result = e.getArrayIndex() + or + index = nArrayIndex and result = e.getQualifier() + or + index = nQualifier and result = e.getFieldNumber() + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class QualifiedStaticField extends @qualified_static_field, FieldSpecification { + override string toString() { result = "QualifiedStaticField" } + + /** + * Gets the class name of this qualified static field, if it exists. + */ + string getClassName() { qualified_static_field_class_names(this, result) } + + /** + * Holds if this qualified static field is enum. + */ + predicate isEnum() { qualified_static_field_is_enum(this) } + + /** + * Gets the name of this qualified static field, if it exists. + */ + string getName() { qualified_static_field_names(this, result) } + } + + private Element getImmediateChildOfQualifiedStaticField(QualifiedStaticField e, int index) { + exists(int n, int nArrayIndex, int nQualifier | + n = 0 and + nArrayIndex = n + 1 and + nQualifier = nArrayIndex + 1 and + ( + none() + or + index = n and result = e.getArrayIndex() + or + index = nArrayIndex and result = e.getQualifier() + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class RetryStatement extends @retry_statement, Statement { + override string toString() { result = "RetryStatement" } + } + + private Element getImmediateChildOfRetryStatement(RetryStatement e, int index) { none() } + + /** + * INTERNAL: Do not use. + */ + class ReturnStatement extends @return_statement, Statement { + override string toString() { result = "ReturnStatement" } + + /** + * Gets the expression of this return statement, if it exists. + */ + Expression getExpression() { return_statement_expressions(this, result) } + } + + private Element getImmediateChildOfReturnStatement(ReturnStatement e, int index) { + exists(int n, int nExpression | + n = 0 and + nExpression = n + 1 and + ( + none() + or + index = n and result = e.getExpression() + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class SearchStatement extends @search_statement, Statement { + override string toString() { result = "SearchStatement" } + + /** + * Gets the query of this search statement, if it exists. + */ + Query getQuery() { search_statement_queries(this, result) } + + /** + * Gets the statement of this search statement, if it exists. + */ + Statement getStatement() { search_statement_statements(this, result) } + } + + private Element getImmediateChildOfSearchStatement(SearchStatement e, int index) { + exists(int n, int nQuery, int nStatement | + n = 0 and + nQuery = n + 1 and + nStatement = nQuery + 1 and + ( + none() + or + index = n and result = e.getQuery() + or + index = nQuery and result = e.getStatement() + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class SimpleField extends @simple_field, FieldSpecification { + override string toString() { result = "SimpleField" } + + /** + * Gets the extension name of this simple field, if it exists. + */ + string getExtensionName() { simple_field_extension_names(this, result) } + + /** + * Holds if this simple field is name escaped. + */ + predicate isNameEscaped() { simple_field_is_name_escaped(this) } + + /** + * Gets the name of this simple field, if it exists. + */ + string getName() { simple_field_names(this, result) } + } + + private Element getImmediateChildOfSimpleField(SimpleField e, int index) { + exists(int n, int nArrayIndex, int nQualifier | + n = 0 and + nArrayIndex = n + 1 and + nQualifier = nArrayIndex + 1 and + ( + none() + or + index = n and result = e.getArrayIndex() + or + index = nArrayIndex and result = e.getQualifier() + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class SimpleInstanceName extends @simple_instance_name, InstanceName { + override string toString() { result = "SimpleInstanceName" } + + /** + * Gets the index of this simple instance name, if it exists. + */ + Expression getIndex() { simple_instance_name_indices(this, result) } + + /** + * Gets the name of this simple instance name, if it exists. + */ + string getName() { simple_instance_name_names(this, result) } + } + + private Element getImmediateChildOfSimpleInstanceName(SimpleInstanceName e, int index) { + exists(int n, int nIndex | + n = 0 and + nIndex = n + 1 and + ( + none() + or + index = n and result = e.getIndex() + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class SimpleOrderElement extends @simple_order_element, OrderElement { + override string toString() { result = "SimpleOrderElement" } + + /** + * Gets the extension name of this simple order element, if it exists. + */ + string getExtensionName() { simple_order_element_extension_names(this, result) } + } + + private Element getImmediateChildOfSimpleOrderElement(SimpleOrderElement e, int index) { none() } + + /** + * INTERNAL: Do not use. + */ + class SimpleQualifier extends @simple_qualifier, Qualifier { + /** + * Gets the name of this simple qualifier, if it exists. + */ + string getName() { simple_qualifier_names(this, result) } + } + + /** + * INTERNAL: Do not use. + */ + class StaticField extends @static_field, FieldSpecification { + override string toString() { result = "StaticField" } + + /** + * Gets the class name of this static field, if it exists. + */ + string getClassName() { static_field_class_names(this, result) } + + /** + * Gets the name of this static field, if it exists. + */ + string getName() { static_field_names(this, result) } + } + + private Element getImmediateChildOfStaticField(StaticField e, int index) { + exists(int n, int nArrayIndex, int nQualifier | + n = 0 and + nArrayIndex = n + 1 and + nQualifier = nArrayIndex + 1 and + ( + none() + or + index = n and result = e.getArrayIndex() + or + index = nArrayIndex and result = e.getQualifier() + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class StringType extends @string_type, XppType { } + + /** + * INTERNAL: Do not use. + */ + class SwitchStatement extends @switch_statement, Statement { + override string toString() { result = "SwitchStatement" } + + /** + * Gets the `index`th case of this switch statement (0-based). + */ + SwitchStatementCaseEntry getCase(int index) { switch_statement_cases(this, index, result) } + + /** + * Gets the number of cases of this switch statement. + */ + int getNumberOfCases() { result = count(int i | switch_statement_cases(this, i, _)) } + + /** + * Gets the selector of this switch statement, if it exists. + */ + Expression getSelector() { switch_statement_selectors(this, result) } + } + + private Element getImmediateChildOfSwitchStatement(SwitchStatement e, int index) { + exists(int n, int nCase, int nSelector | + n = 0 and + nCase = n + e.getNumberOfCases() and + nSelector = nCase + 1 and + ( + none() + or + result = e.getCase(index - n) + or + index = nCase and result = e.getSelector() + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class TableLookupExpression extends @table_lookup_expression, Expression { + override string toString() { result = "TableLookupExpression" } + + /** + * Gets the field of this table lookup expression, if it exists. + */ + TableFieldReference getField() { table_lookup_expression_fields(this, result) } + + /** + * Gets the query of this table lookup expression, if it exists. + */ + Query getQuery() { table_lookup_expression_queries(this, result) } + } + + private Element getImmediateChildOfTableLookupExpression(TableLookupExpression e, int index) { + exists(int n, int nTransformation, int nField, int nQuery | + n = 0 and + nTransformation = n + 1 and + nField = nTransformation + 1 and + nQuery = nField + 1 and + ( + none() + or + index = n and result = e.getTransformation() + or + index = nTransformation and result = e.getField() + or + index = nField and result = e.getQuery() + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class ThrowStatement extends @throw_statement, Statement { + override string toString() { result = "ThrowStatement" } + + /** + * Gets the exception of this throw statement, if it exists. + */ + Expression getException() { throw_statement_exceptions(this, result) } + } + + private Element getImmediateChildOfThrowStatement(ThrowStatement e, int index) { + exists(int n, int nException | + n = 0 and + nException = n + 1 and + ( + none() + or + index = n and result = e.getException() + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class TryStatement extends @try_statement, Statement { + override string toString() { result = "TryStatement" } + + /** + * Gets the `index`th catch of this try statement (0-based). + */ + TryStatementCatchEntry getCatch(int index) { try_statement_catches(this, index, result) } + + /** + * Gets the number of catches of this try statement. + */ + int getNumberOfCatches() { result = count(int i | try_statement_catches(this, i, _)) } + + /** + * Gets the finally of this try statement, if it exists. + */ + Statement getFinally() { try_statement_finallies(this, result) } + + /** + * Gets the statement of this try statement, if it exists. + */ + Statement getStatement() { try_statement_statements(this, result) } + } + + private Element getImmediateChildOfTryStatement(TryStatement e, int index) { + exists(int n, int nCatch, int nFinally, int nStatement | + n = 0 and + nCatch = n + e.getNumberOfCatches() and + nFinally = nCatch + 1 and + nStatement = nFinally + 1 and + ( + none() + or + result = e.getCatch(index - n) + or + index = nCatch and result = e.getFinally() + or + index = nFinally and result = e.getStatement() + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class TtsStatement extends @tts_statement, Statement { } + + /** + * INTERNAL: Do not use. + */ + class UnaryExpression extends @unary_expression, Expression { + /** + * Gets the expression of this unary expression, if it exists. + */ + Expression getExpression() { unary_expression_expressions(this, result) } + } + + /** + * INTERNAL: Do not use. + */ + class UncheckedStatement extends @unchecked_statement, Statement { + override string toString() { result = "UncheckedStatement" } + + /** + * Gets the expression of this unchecked statement, if it exists. + */ + Expression getExpression() { unchecked_statement_expressions(this, result) } + + /** + * Gets the statement of this unchecked statement, if it exists. + */ + Statement getStatement() { unchecked_statement_statements(this, result) } + } + + private Element getImmediateChildOfUncheckedStatement(UncheckedStatement e, int index) { + exists(int n, int nExpression, int nStatement | + n = 0 and + nExpression = n + 1 and + nStatement = nExpression + 1 and + ( + none() + or + index = n and result = e.getExpression() + or + index = nExpression and result = e.getStatement() + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class UpdateStatement extends @update_statement, Statement { + override string toString() { result = "UpdateStatement" } + + /** + * Gets the cross company of this update statement, if it exists. + */ + CrossCompany getCrossCompany() { update_statement_cross_companies(this, result) } + + /** + * Gets the `index`th field assignment of this update statement (0-based). + */ + FieldAssignment getFieldAssignment(int index) { + update_statement_field_assignments(this, index, result) + } + + /** + * Gets the number of field assignments of this update statement. + */ + int getNumberOfFieldAssignments() { + result = count(int i | update_statement_field_assignments(this, i, _)) + } + + /** + * Gets the `index`th hint of this update statement (0-based). + */ + string getHint(int index) { update_statement_hints(this, index, result) } + + /** + * Gets the number of hints of this update statement. + */ + int getNumberOfHints() { result = count(int i | update_statement_hints(this, i, _)) } + + /** + * Gets the joins of this update statement, if it exists. + */ + JoinSpecification getJoins() { update_statement_joins(this, result) } + + /** + * Gets the table of this update statement, if it exists. + */ + string getTable() { update_statement_tables(this, result) } + + /** + * Gets the where of this update statement, if it exists. + */ + Expression getWhere() { update_statement_wheres(this, result) } + } + + private Element getImmediateChildOfUpdateStatement(UpdateStatement e, int index) { + exists(int n, int nCrossCompany, int nFieldAssignment, int nJoins, int nWhere | + n = 0 and + nCrossCompany = n + 1 and + nFieldAssignment = nCrossCompany + e.getNumberOfFieldAssignments() and + nJoins = nFieldAssignment + 1 and + nWhere = nJoins + 1 and + ( + none() + or + index = n and result = e.getCrossCompany() + or + result = e.getFieldAssignment(index - nCrossCompany) + or + index = nFieldAssignment and result = e.getJoins() + or + index = nJoins and result = e.getWhere() + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class UsingStatement extends @using_statement, Statement { + override string toString() { result = "UsingStatement" } + + /** + * Gets the `index`th disposable object initializer of this using statement (0-based). + */ + VariableDeclaration getDisposableObjectInitializer(int index) { + using_statement_disposable_object_initializers(this, index, result) + } + + /** + * Gets the number of disposable object initializers of this using statement. + */ + int getNumberOfDisposableObjectInitializers() { + result = count(int i | using_statement_disposable_object_initializers(this, i, _)) + } + + /** + * Gets the statement of this using statement, if it exists. + */ + Statement getStatement() { using_statement_statements(this, result) } + } + + private Element getImmediateChildOfUsingStatement(UsingStatement e, int index) { + exists(int n, int nDisposableObjectInitializer, int nStatement | + n = 0 and + nDisposableObjectInitializer = n + e.getNumberOfDisposableObjectInitializers() and + nStatement = nDisposableObjectInitializer + 1 and + ( + none() + or + result = e.getDisposableObjectInitializer(index - n) + or + index = nDisposableObjectInitializer and result = e.getStatement() + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class ValidTimeStateDate extends @valid_time_state_date, ValidTimeState { + override string toString() { result = "ValidTimeStateDate" } + + /** + * Gets the date variable of this valid time state date, if it exists. + */ + string getDateVariable() { valid_time_state_date_date_variables(this, result) } + } + + private Element getImmediateChildOfValidTimeStateDate(ValidTimeStateDate e, int index) { none() } + + /** + * INTERNAL: Do not use. + */ + class ValidTimeStateRange extends @valid_time_state_range, ValidTimeState { + override string toString() { result = "ValidTimeStateRange" } + + /** + * Gets the from date variable of this valid time state range, if it exists. + */ + string getFromDateVariable() { valid_time_state_range_from_date_variables(this, result) } + + /** + * Gets the to date variable of this valid time state range, if it exists. + */ + string getToDateVariable() { valid_time_state_range_to_date_variables(this, result) } + } + + private Element getImmediateChildOfValidTimeStateRange(ValidTimeStateRange e, int index) { + none() + } + + /** + * INTERNAL: Do not use. + */ + class VarType extends @var_type, XppType { + override string toString() { result = "VarType" } + } + + private Element getImmediateChildOfVarType(VarType e, int index) { none() } + + /** + * INTERNAL: Do not use. + */ + class VoidType extends @void_type, XppType { + override string toString() { result = "VoidType" } + } + + private Element getImmediateChildOfVoidType(VoidType e, int index) { none() } + + /** + * INTERNAL: Do not use. + */ + class WhileStatement extends @while_statement, Statement { + override string toString() { result = "WhileStatement" } + + /** + * Gets the condition of this while statement, if it exists. + */ + Expression getCondition() { while_statement_conditions(this, result) } + + /** + * Gets the statement of this while statement, if it exists. + */ + Statement getStatement() { while_statement_statements(this, result) } + } + + private Element getImmediateChildOfWhileStatement(WhileStatement e, int index) { + exists(int n, int nCondition, int nStatement | + n = 0 and + nCondition = n + 1 and + nStatement = nCondition + 1 and + ( + none() + or + index = n and result = e.getCondition() + or + index = nCondition and result = e.getStatement() + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class XppTypeCompilationUnit extends @xpp_type_compilation_unit, CompilationUnit { + override string toString() { result = "XppTypeCompilationUnit" } + + /** + * Gets the type of this xpp type compilation unit, if it exists. + */ + XppType getType() { xpp_type_compilation_unit_types(this, result) } + } + + private Element getImmediateChildOfXppTypeCompilationUnit(XppTypeCompilationUnit e, int index) { + exists(int n, int nComments, int nRegion, int nType | + n = 0 and + nComments = n + 1 and + nRegion = nComments + e.getNumberOfRegions() and + nType = nRegion + 1 and + ( + none() + or + index = n and result = e.getComments() + or + result = e.getRegion(index - nComments) + or + index = nRegion and result = e.getType() + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class AddExpression extends @add_expression, BinaryExpression { + override string toString() { result = "AddExpression" } + } + + private Element getImmediateChildOfAddExpression(AddExpression e, int index) { + exists(int n, int nTransformation, int nLeft, int nRight | + n = 0 and + nTransformation = n + 1 and + nLeft = nTransformation + 1 and + nRight = nLeft + 1 and + ( + none() + or + index = n and result = e.getTransformation() + or + index = nTransformation and result = e.getLeft() + or + index = nLeft and result = e.getRight() + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class AndExpression extends @and_expression, BinaryExpression { + override string toString() { result = "AndExpression" } + } + + private Element getImmediateChildOfAndExpression(AndExpression e, int index) { + exists(int n, int nTransformation, int nLeft, int nRight | + n = 0 and + nTransformation = n + 1 and + nLeft = nTransformation + 1 and + nRight = nLeft + 1 and + ( + none() + or + index = n and result = e.getTransformation() + or + index = nTransformation and result = e.getLeft() + or + index = nLeft and result = e.getRight() + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class AsClrExpression extends @as_clr_expression, IsAsExpression { + override string toString() { result = "AsClrExpression" } + } + + private Element getImmediateChildOfAsClrExpression(AsClrExpression e, int index) { + exists(int n, int nTransformation, int nExpression | + n = 0 and + nTransformation = n + 1 and + nExpression = nTransformation + 1 and + ( + none() + or + index = n and result = e.getTransformation() + or + index = nTransformation and result = e.getExpression() + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class AsExpression extends @as_expression, IsAsExpression { + override string toString() { result = "AsExpression" } + } + + private Element getImmediateChildOfAsExpression(AsExpression e, int index) { + exists(int n, int nTransformation, int nExpression | + n = 0 and + nTransformation = n + 1 and + nExpression = nTransformation + 1 and + ( + none() + or + index = n and result = e.getTransformation() + or + index = nTransformation and result = e.getExpression() + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class AssignMultipleFieldStatement extends @assign_multiple_field_statement, AssignmentStatement { + override string toString() { result = "AssignMultipleFieldStatement" } + + /** + * Gets the expression of this assign multiple field statement, if it exists. + */ + Expression getExpression() { assign_multiple_field_statement_expressions(this, result) } + + /** + * Gets the `index`th field of this assign multiple field statement (0-based). + */ + FieldSpecification getField(int index) { + assign_multiple_field_statement_fields(this, index, result) + } + + /** + * Gets the number of fields of this assign multiple field statement. + */ + int getNumberOfFields() { + result = count(int i | assign_multiple_field_statement_fields(this, i, _)) + } + } + + private Element getImmediateChildOfAssignMultipleFieldStatement( + AssignMultipleFieldStatement e, int index + ) { + exists(int n, int nExpression, int nField | + n = 0 and + nExpression = n + 1 and + nField = nExpression + e.getNumberOfFields() and + ( + none() + or + index = n and result = e.getExpression() + or + result = e.getField(index - nExpression) + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class AssignmentSingleField extends @assignment_single_field, AssignmentStatement { + /** + * Gets the field of this assignment single field, if it exists. + */ + FieldSpecification getField() { assignment_single_field_fields(this, result) } + } + + /** + * INTERNAL: Do not use. + */ + class AvgAggregateSelection extends @avg_aggregate_selection, AggregateSelection { + override string toString() { result = "AvgAggregateSelection" } + } + + private Element getImmediateChildOfAvgAggregateSelection(AvgAggregateSelection e, int index) { + none() + } + + /** + * INTERNAL: Do not use. + */ + class BooleanAttributeLiteral extends @boolean_attribute_literal, DefaultTypeAttributeLiteral { + override string toString() { result = "BooleanAttributeLiteral" } + } + + private Element getImmediateChildOfBooleanAttributeLiteral(BooleanAttributeLiteral e, int index) { + none() + } + + /** + * INTERNAL: Do not use. + */ + class ChangeCompanyStatement extends @change_company_statement, ChangeStatement { + override string toString() { result = "ChangeCompanyStatement" } + } + + private Element getImmediateChildOfChangeCompanyStatement(ChangeCompanyStatement e, int index) { + exists(int n, int nExpression, int nStatement | + n = 0 and + nExpression = n + 1 and + nStatement = nExpression + 1 and + ( + none() + or + index = n and result = e.getExpression() + or + index = nExpression and result = e.getStatement() + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class ClassOrInterface extends @class_or_interface, ModelElement { + /** + * Gets the attributes of this class or interface, if it exists. + */ + AttributeList getAttributes() { class_or_interface_attributes(this, result) } + + /** + * Gets the element type name of this class or interface, if it exists. + */ + string getElementTypeName() { class_or_interface_element_type_names(this, result) } + + /** + * Gets the enclosing type of this class or interface, if it exists. + */ + ModelElement getEnclosingType() { class_or_interface_enclosing_types(this, result) } + + /** + * Gets the extends of this class or interface, if it exists. + */ + string getExtends() { class_or_interface_extends(this, result) } + + /** + * Holds if this class or interface is abstract. + */ + predicate isAbstract() { class_or_interface_is_abstract(this) } + + /** + * Holds if this class or interface is composite data entity view. + */ + predicate isCompositeDataEntityView() { class_or_interface_is_composite_data_entity_view(this) } + + /** + * Holds if this class or interface is final. + */ + predicate isFinal() { class_or_interface_is_final(this) } + + /** + * Holds if this class or interface is nested. + */ + predicate isNested() { class_or_interface_is_nested(this) } + + /** + * Holds if this class or interface is static. + */ + predicate isStatic() { class_or_interface_is_static(this) } + + /** + * Gets the qualifier of this class or interface, if it exists. + */ + string getQualifier() { class_or_interface_qualifiers(this, result) } + } + + /** + * INTERNAL: Do not use. + */ + class ClrEnumerationLiteralExpression extends @clr_enumeration_literal_expression, + LiteralExpression + { + override string toString() { result = "ClrEnumerationLiteralExpression" } + + /** + * Gets the enumeration literal of this clr enumeration literal expression, if it exists. + */ + string getEnumerationLiteral() { + clr_enumeration_literal_expression_enumeration_literals(this, result) + } + + /** + * Gets the enumeration type of this clr enumeration literal expression, if it exists. + */ + string getEnumerationType() { + clr_enumeration_literal_expression_enumeration_types(this, result) + } + } + + private Element getImmediateChildOfClrEnumerationLiteralExpression( + ClrEnumerationLiteralExpression e, int index + ) { + exists(int n, int nTransformation | + n = 0 and + nTransformation = n + 1 and + ( + none() + or + index = n and result = e.getTransformation() + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class ClrType extends @clr_type, GenericXppType { + override string toString() { result = "ClrType" } + + /** + * Gets the full name of this clr type, if it exists. + */ + string getFullName() { clr_type_full_names(this, result) } + + /** + * Gets the `index`th rectangular dimension of this clr type (0-based). + */ + int getRectangularDimension(int index) { clr_type_rectangular_dimensions(this, index, result) } + + /** + * Gets the number of rectangular dimensions of this clr type. + */ + int getNumberOfRectangularDimensions() { + result = count(int i | clr_type_rectangular_dimensions(this, i, _)) + } + } + + private Element getImmediateChildOfClrType(ClrType e, int index) { + exists(int n, int nTypeArgumentList | + n = 0 and + nTypeArgumentList = n + e.getNumberOfTypeArgumentLists() and + ( + none() + or + result = e.getTypeArgumentList(index - n) + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class ContainerLiteralExpression extends @container_literal_expression, LiteralExpression { + override string toString() { result = "ContainerLiteralExpression" } + + /** + * Gets the `index`th value of this container literal expression (0-based). + */ + Expression getValue(int index) { container_literal_expression_values(this, index, result) } + + /** + * Gets the number of values of this container literal expression. + */ + int getNumberOfValues() { + result = count(int i | container_literal_expression_values(this, i, _)) + } + } + + private Element getImmediateChildOfContainerLiteralExpression( + ContainerLiteralExpression e, int index + ) { + exists(int n, int nTransformation, int nValue | + n = 0 and + nTransformation = n + 1 and + nValue = nTransformation + e.getNumberOfValues() and + ( + none() + or + index = n and result = e.getTransformation() + or + result = e.getValue(index - nTransformation) + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class CountAggregateSelection extends @count_aggregate_selection, AggregateSelection { + override string toString() { result = "CountAggregateSelection" } + } + + private Element getImmediateChildOfCountAggregateSelection(CountAggregateSelection e, int index) { + none() + } + + /** + * INTERNAL: Do not use. + */ + class DateAttributeLiteral extends @date_attribute_literal, DefaultTypeAttributeLiteral { + override string toString() { result = "DateAttributeLiteral" } + } + + private Element getImmediateChildOfDateAttributeLiteral(DateAttributeLiteral e, int index) { + none() + } + + /** + * INTERNAL: Do not use. + */ + class DateTimeAttributeLiteral extends @date_time_attribute_literal, DefaultTypeAttributeLiteral { + override string toString() { result = "DateTimeAttributeLiteral" } + } + + private Element getImmediateChildOfDateTimeAttributeLiteral(DateTimeAttributeLiteral e, int index) { + none() + } + + /** + * INTERNAL: Do not use. + */ + class DblAttributeLiteral extends @dbl_attribute_literal, DefaultTypeAttributeLiteral { + override string toString() { result = "DblAttributeLiteral" } + } + + private Element getImmediateChildOfDblAttributeLiteral(DblAttributeLiteral e, int index) { + none() + } + + /** + * INTERNAL: Do not use. + */ + class DefaultTypeLiteralExpression extends @default_type_literal_expression, LiteralExpression { + /** + * Gets the scanned literal value of this default type literal expression, if it exists. + */ + string getScannedLiteralValue() { + default_type_literal_expression_scanned_literal_values(this, result) + } + } + + /** + * INTERNAL: Do not use. + */ + class Delegate extends @delegate, MethodOrDelegate { + override string toString() { result = "Delegate" } + + /** + * Holds if this delegate is static. + */ + predicate isStatic() { delegate_is_static(this) } + } + + private Element getImmediateChildOfDelegate(Delegate e, int index) { + exists( + int n, int nComments, int nRegion, int nAttributes, int nModifierList, int nParameter, + int nType + | + n = 0 and + nComments = n + 1 and + nRegion = nComments + e.getNumberOfRegions() and + nAttributes = nRegion + 1 and + nModifierList = nAttributes + e.getNumberOfModifierLists() and + nParameter = nModifierList + e.getNumberOfParameters() and + nType = nParameter + 1 and + ( + none() + or + index = n and result = e.getComments() + or + result = e.getRegion(index - nComments) + or + index = nRegion and result = e.getAttributes() + or + result = e.getModifierList(index - nAttributes) + or + result = e.getParameter(index - nModifierList) + or + index = nParameter and result = e.getType() + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class DivideExpression extends @divide_expression, BinaryExpression { + override string toString() { result = "DivideExpression" } + } + + private Element getImmediateChildOfDivideExpression(DivideExpression e, int index) { + exists(int n, int nTransformation, int nLeft, int nRight | + n = 0 and + nTransformation = n + 1 and + nLeft = nTransformation + 1 and + nRight = nLeft + 1 and + ( + none() + or + index = n and result = e.getTransformation() + or + index = nTransformation and result = e.getLeft() + or + index = nLeft and result = e.getRight() + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class EnumerationLiteralExpression extends @enumeration_literal_expression, LiteralExpression { + override string toString() { result = "EnumerationLiteralExpression" } + + /** + * Gets the enumeration literal of this enumeration literal expression, if it exists. + */ + string getEnumerationLiteral() { + enumeration_literal_expression_enumeration_literals(this, result) + } + + /** + * Gets the enumeration type of this enumeration literal expression, if it exists. + */ + string getEnumerationType() { enumeration_literal_expression_enumeration_types(this, result) } + } + + private Element getImmediateChildOfEnumerationLiteralExpression( + EnumerationLiteralExpression e, int index + ) { + exists(int n, int nTransformation | + n = 0 and + nTransformation = n + 1 and + ( + none() + or + index = n and result = e.getTransformation() + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class FieldDeclaration extends @field_declaration, Declaration { + /** + * Gets the attributes of this field declaration, if it exists. + */ + AttributeList getAttributes() { field_declaration_attributes(this, result) } + + /** + * Gets the element type name of this field declaration, if it exists. + */ + string getElementTypeName() { field_declaration_element_type_names(this, result) } + + /** + * Gets the extension name of this field declaration, if it exists. + */ + string getExtensionName() { field_declaration_extension_names(this, result) } + + /** + * Gets the initial value of this field declaration, if it exists. + */ + Expression getInitialValue() { field_declaration_initial_values(this, result) } + + /** + * Holds if this field declaration is const. + */ + predicate isConst() { field_declaration_is_const(this) } + + /** + * Holds if this field declaration is extension. + */ + predicate isExtension() { field_declaration_is_extension(this) } + + /** + * Holds if this field declaration is internal. + */ + predicate isInternal() { field_declaration_is_internal(this) } + + /** + * Holds if this field declaration is obsolete. + */ + predicate isObsolete() { field_declaration_is_obsolete(this) } + + /** + * Holds if this field declaration is private. + */ + predicate isPrivate() { field_declaration_is_private(this) } + + /** + * Holds if this field declaration is protected. + */ + predicate isProtected() { field_declaration_is_protected(this) } + + /** + * Holds if this field declaration is public. + */ + predicate isPublic() { field_declaration_is_public(this) } + + /** + * Holds if this field declaration is read only. + */ + predicate isReadOnly() { field_declaration_is_read_only(this) } + + /** + * Holds if this field declaration is static. + */ + predicate isStatic() { field_declaration_is_static(this) } + } + + /** + * INTERNAL: Do not use. + */ + class FieldExpressionInternal extends @field_expression_internal, FieldExpression { + override string toString() { result = "FieldExpressionInternal" } + } + + private Element getImmediateChildOfFieldExpressionInternal(FieldExpressionInternal e, int index) { + exists(int n, int nTransformation, int nField | + n = 0 and + nTransformation = n + 1 and + nField = nTransformation + 1 and + ( + none() + or + index = n and result = e.getTransformation() + or + index = nTransformation and result = e.getField() + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class ForFieldAssign extends @for_field_assign, ForExpressionAssign { + override string toString() { result = "ForFieldAssign" } + } + + private Element getImmediateChildOfForFieldAssign(ForFieldAssign e, int index) { + exists(int n, int nFieldSpecification, int nExpression | + n = 0 and + nFieldSpecification = n + 1 and + nExpression = nFieldSpecification + 1 and + ( + none() + or + index = n and result = e.getFieldSpecification() + or + index = nFieldSpecification and result = e.getExpression() + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class ForFieldDecrementAssign extends @for_field_decrement_assign, ForExpressionAssign { + override string toString() { result = "ForFieldDecrementAssign" } + } + + private Element getImmediateChildOfForFieldDecrementAssign(ForFieldDecrementAssign e, int index) { + exists(int n, int nFieldSpecification, int nExpression | + n = 0 and + nFieldSpecification = n + 1 and + nExpression = nFieldSpecification + 1 and + ( + none() + or + index = n and result = e.getFieldSpecification() + or + index = nFieldSpecification and result = e.getExpression() + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class ForFieldIncrementAssign extends @for_field_increment_assign, ForExpressionAssign { + override string toString() { result = "ForFieldIncrementAssign" } + } + + private Element getImmediateChildOfForFieldIncrementAssign(ForFieldIncrementAssign e, int index) { + exists(int n, int nFieldSpecification, int nExpression | + n = 0 and + nFieldSpecification = n + 1 and + nExpression = nFieldSpecification + 1 and + ( + none() + or + index = n and result = e.getFieldSpecification() + or + index = nFieldSpecification and result = e.getExpression() + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class FormModelElement extends @form_model_element, ModelElement { + override string toString() { result = "FormModelElement" } + + /** + * Gets the behavior of this form model element, if it exists. + */ + Class getBehavior() { form_model_element_behaviors(this, result) } + + /** + * Gets the `index`th control of this form model element (0-based). + */ + FormControl getControl(int index) { form_model_element_controls(this, index, result) } + + /** + * Gets the number of controls of this form model element. + */ + int getNumberOfControls() { result = count(int i | form_model_element_controls(this, i, _)) } + + /** + * Gets the `index`th data source of this form model element (0-based). + */ + FormDataSource getDataSource(int index) { form_model_element_data_sources(this, index, result) } + + /** + * Gets the number of data sources of this form model element. + */ + int getNumberOfDataSources() { + result = count(int i | form_model_element_data_sources(this, i, _)) + } + + /** + * Gets the element type name of this form model element, if it exists. + */ + string getElementTypeName() { form_model_element_element_type_names(this, result) } + + /** + * Gets the full type name of this form model element, if it exists. + */ + string getFullTypeName() { form_model_element_full_type_names(this, result) } + } + + private Element getImmediateChildOfFormModelElement(FormModelElement e, int index) { + exists( + int n, int nComments, int nRegion, int nBaseMethod, int nExtendGenericParameter, int nMethod, + int nModifierList, int nNestedClass, int nUsing, int nBehavior, int nControl, int nDataSource + | + n = 0 and + nComments = n + 1 and + nRegion = nComments + e.getNumberOfRegions() and + nBaseMethod = nRegion + e.getNumberOfBaseMethods() and + nExtendGenericParameter = nBaseMethod + e.getNumberOfExtendGenericParameters() and + nMethod = nExtendGenericParameter + e.getNumberOfMethods() and + nModifierList = nMethod + e.getNumberOfModifierLists() and + nNestedClass = nModifierList + e.getNumberOfNestedClasses() and + nUsing = nNestedClass + e.getNumberOfUsings() and + nBehavior = nUsing + 1 and + nControl = nBehavior + e.getNumberOfControls() and + nDataSource = nControl + e.getNumberOfDataSources() and + ( + none() + or + index = n and result = e.getComments() + or + result = e.getRegion(index - nComments) + or + result = e.getBaseMethod(index - nRegion) + or + result = e.getExtendGenericParameter(index - nBaseMethod) + or + result = e.getMethod(index - nExtendGenericParameter) + or + result = e.getModifierList(index - nMethod) + or + result = e.getNestedClass(index - nModifierList) + or + result = e.getUsing(index - nNestedClass) + or + index = nUsing and result = e.getBehavior() + or + result = e.getControl(index - nBehavior) + or + result = e.getDataSource(index - nControl) + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class FormNestedElement extends @form_nested_element, ModelElement { + /** + * Gets the form of this form nested element, if it exists. + */ + FormModelElement getForm() { form_nested_element_forms(this, result) } + } + + /** + * INTERNAL: Do not use. + */ + class GenericEvaluation extends @generic_evaluation, Evaluation { + /** + * Gets the `index`th type argument list of this generic evaluation (0-based). + */ + XppType getTypeArgumentList(int index) { + generic_evaluation_type_argument_lists(this, index, result) + } + + /** + * Gets the number of type argument lists of this generic evaluation. + */ + int getNumberOfTypeArgumentLists() { + result = count(int i | generic_evaluation_type_argument_lists(this, i, _)) + } + } + + /** + * INTERNAL: Do not use. + */ + class GuidAttributeLiteral extends @guid_attribute_literal, DefaultTypeAttributeLiteral { + override string toString() { result = "GuidAttributeLiteral" } + } + + private Element getImmediateChildOfGuidAttributeLiteral(GuidAttributeLiteral e, int index) { + none() + } + + /** + * INTERNAL: Do not use. + */ + class InExpression extends @in_expression, BinaryExpression { + override string toString() { result = "InExpression" } + } + + private Element getImmediateChildOfInExpression(InExpression e, int index) { + exists(int n, int nTransformation, int nLeft, int nRight | + n = 0 and + nTransformation = n + 1 and + nLeft = nTransformation + 1 and + nRight = nLeft + 1 and + ( + none() + or + index = n and result = e.getTransformation() + or + index = nTransformation and result = e.getLeft() + or + index = nLeft and result = e.getRight() + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class Int64AttributeLiteral extends @int64_attribute_literal, DefaultTypeAttributeLiteral { + override string toString() { result = "Int64AttributeLiteral" } + } + + private Element getImmediateChildOfInt64AttributeLiteral(Int64AttributeLiteral e, int index) { + none() + } + + /** + * INTERNAL: Do not use. + */ + class IntAttributeLiteral extends @int_attribute_literal, DefaultTypeAttributeLiteral { + override string toString() { result = "IntAttributeLiteral" } + } + + private Element getImmediateChildOfIntAttributeLiteral(IntAttributeLiteral e, int index) { + none() + } + + /** + * INTERNAL: Do not use. + */ + class IntegerDivideExpression extends @integer_divide_expression, BinaryExpression { + override string toString() { result = "IntegerDivideExpression" } + } + + private Element getImmediateChildOfIntegerDivideExpression(IntegerDivideExpression e, int index) { + exists(int n, int nTransformation, int nLeft, int nRight | + n = 0 and + nTransformation = n + 1 and + nLeft = nTransformation + 1 and + nRight = nLeft + 1 and + ( + none() + or + index = n and result = e.getTransformation() + or + index = nTransformation and result = e.getLeft() + or + index = nLeft and result = e.getRight() + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class IsClrExpression extends @is_clr_expression, IsAsExpression { + override string toString() { result = "IsClrExpression" } + } + + private Element getImmediateChildOfIsClrExpression(IsClrExpression e, int index) { + exists(int n, int nTransformation, int nExpression | + n = 0 and + nTransformation = n + 1 and + nExpression = nTransformation + 1 and + ( + none() + or + index = n and result = e.getTransformation() + or + index = nTransformation and result = e.getExpression() + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class IsExpression extends @is_expression, IsAsExpression { + override string toString() { result = "IsExpression" } + } + + private Element getImmediateChildOfIsExpression(IsExpression e, int index) { + exists(int n, int nTransformation, int nExpression | + n = 0 and + nTransformation = n + 1 and + nExpression = nTransformation + 1 and + ( + none() + or + index = n and result = e.getTransformation() + or + index = nTransformation and result = e.getExpression() + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class LocalDeclaration extends @local_declaration, Declaration { } + + /** + * INTERNAL: Do not use. + */ + class MaxAggregateSelection extends @max_aggregate_selection, AggregateSelection { + override string toString() { result = "MaxAggregateSelection" } + } + + private Element getImmediateChildOfMaxAggregateSelection(MaxAggregateSelection e, int index) { + none() + } + + /** + * INTERNAL: Do not use. + */ + class Method extends @method, MethodOrDelegate { + override string toString() { result = "Method" } + + /** + * Gets the `index`th declarations and statement of this method (0-based). + */ + Statement getDeclarationsAndStatement(int index) { + method_declarations_and_statements(this, index, result) + } + + /** + * Gets the number of declarations and statements of this method. + */ + int getNumberOfDeclarationsAndStatements() { + result = count(int i | method_declarations_and_statements(this, i, _)) + } + + /** + * Holds if this method has local functions. + */ + predicate hasLocalFunctions() { method_has_local_functions(this) } + + /** + * Holds if this method is abstract. + */ + predicate isAbstract() { method_is_abstract(this) } + + /** + * Holds if this method is client. + */ + predicate isClient() { method_is_client(this) } + + /** + * Holds if this method is constructor. + */ + predicate isConstructor() { method_is_constructor(this) } + + /** + * Holds if this method is display. + */ + predicate isDisplay() { method_is_display(this) } + + /** + * Holds if this method is edit. + */ + predicate isEdit() { method_is_edit(this) } + + /** + * Holds if this method is explicit non hookable. + */ + predicate isExplicitNonHookable() { method_is_explicit_non_hookable(this) } + + /** + * Holds if this method is explicit non wrappable. + */ + predicate isExplicitNonWrappable() { method_is_explicit_non_wrappable(this) } + + /** + * Holds if this method is extended method. + */ + predicate isExtendedMethod() { method_is_extended_method(this) } + + /** + * Holds if this method is final. + */ + predicate isFinal() { method_is_final(this) } + + /** + * Holds if this method is hookable. + */ + predicate isHookable() { method_is_hookable(this) } + + /** + * Holds if this method is hookable on chain of command. + */ + predicate isHookableOnChainOfCommand() { method_is_hookable_on_chain_of_command(this) } + + /** + * Holds if this method is internal. + */ + predicate isInternal() { method_is_internal(this) } + + /** + * Holds if this method is private. + */ + predicate isPrivate() { method_is_private(this) } + + /** + * Holds if this method is protected. + */ + predicate isProtected() { method_is_protected(this) } + + /** + * Holds if this method is public. + */ + predicate isPublic() { method_is_public(this) } + + /** + * Holds if this method is replaceable. + */ + predicate isReplaceable() { method_is_replaceable(this) } + + /** + * Holds if this method is server. + */ + predicate isServer() { method_is_server(this) } + + /** + * Holds if this method is static. + */ + predicate isStatic() { method_is_static(this) } + + /** + * Holds if this method is type initializer. + */ + predicate isTypeInitializer() { method_is_type_initializer(this) } + + /** + * Holds if this method is wrappable. + */ + predicate isWrappable() { method_is_wrappable(this) } + + /** + * Gets the `index`th local of this method (0-based). + */ + LocalDeclaration getLocal(int index) { method_locals(this, index, result) } + + /** + * Gets the number of locals of this method. + */ + int getNumberOfLocals() { result = count(int i | method_locals(this, i, _)) } + + /** + * Gets the modifiers of this method, if it exists. + */ + string getModifiers() { method_modifiers(this, result) } + + /** + * Gets the `index`th statement of this method (0-based). + */ + Statement getStatement(int index) { method_statements(this, index, result) } + + /** + * Gets the number of statements of this method. + */ + int getNumberOfStatements() { result = count(int i | method_statements(this, i, _)) } + } + + private Element getImmediateChildOfMethod(Method e, int index) { + exists( + int n, int nComments, int nRegion, int nAttributes, int nModifierList, int nParameter, + int nType, int nDeclarationsAndStatement, int nLocal, int nStatement + | + n = 0 and + nComments = n + 1 and + nRegion = nComments + e.getNumberOfRegions() and + nAttributes = nRegion + 1 and + nModifierList = nAttributes + e.getNumberOfModifierLists() and + nParameter = nModifierList + e.getNumberOfParameters() and + nType = nParameter + 1 and + nDeclarationsAndStatement = nType + e.getNumberOfDeclarationsAndStatements() and + nLocal = nDeclarationsAndStatement + e.getNumberOfLocals() and + nStatement = nLocal + e.getNumberOfStatements() and + ( + none() + or + index = n and result = e.getComments() + or + result = e.getRegion(index - nComments) + or + index = nRegion and result = e.getAttributes() + or + result = e.getModifierList(index - nAttributes) + or + result = e.getParameter(index - nModifierList) + or + index = nParameter and result = e.getType() + or + result = e.getDeclarationsAndStatement(index - nType) + or + result = e.getLocal(index - nDeclarationsAndStatement) + or + result = e.getStatement(index - nLocal) + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class MinAggregateSelection extends @min_aggregate_selection, AggregateSelection { + override string toString() { result = "MinAggregateSelection" } + } + + private Element getImmediateChildOfMinAggregateSelection(MinAggregateSelection e, int index) { + none() + } + + /** + * INTERNAL: Do not use. + */ + class ModExpression extends @mod_expression, BinaryExpression { + override string toString() { result = "ModExpression" } + } + + private Element getImmediateChildOfModExpression(ModExpression e, int index) { + exists(int n, int nTransformation, int nLeft, int nRight | + n = 0 and + nTransformation = n + 1 and + nLeft = nTransformation + 1 and + nRight = nLeft + 1 and + ( + none() + or + index = n and result = e.getTransformation() + or + index = nTransformation and result = e.getLeft() + or + index = nLeft and result = e.getRight() + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class MultiplyExpression extends @multiply_expression, BinaryExpression { + override string toString() { result = "MultiplyExpression" } + } + + private Element getImmediateChildOfMultiplyExpression(MultiplyExpression e, int index) { + exists(int n, int nTransformation, int nLeft, int nRight | + n = 0 and + nTransformation = n + 1 and + nLeft = nTransformation + 1 and + nRight = nLeft + 1 and + ( + none() + or + index = n and result = e.getTransformation() + or + index = nTransformation and result = e.getLeft() + or + index = nLeft and result = e.getRight() + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class NamedType extends @named_type, GenericXppType { + /** + * Gets the name of this named type, if it exists. + */ + string getName() { named_type_names(this, result) } + } + + /** + * INTERNAL: Do not use. + */ + class NewCall extends @new_call, Evaluation { + override string toString() { result = "NewCall" } + + /** + * Gets the type of this new call, if it exists. + */ + XppType getType() { new_call_types(this, result) } + } + + private Element getImmediateChildOfNewCall(NewCall e, int index) { + exists(int n, int nTransformation, int nActualParameter, int nType | + n = 0 and + nTransformation = n + 1 and + nActualParameter = nTransformation + e.getNumberOfActualParameters() and + nType = nActualParameter + 1 and + ( + none() + or + index = n and result = e.getTransformation() + or + result = e.getActualParameter(index - nTransformation) + or + index = nActualParameter and result = e.getType() + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class NextExpression extends @next_expression, Evaluation { + override string toString() { result = "NextExpression" } + + /** + * Gets the name of this next expression, if it exists. + */ + string getName() { next_expression_names(this, result) } + } + + private Element getImmediateChildOfNextExpression(NextExpression e, int index) { + exists(int n, int nTransformation, int nActualParameter | + n = 0 and + nTransformation = n + 1 and + nActualParameter = nTransformation + e.getNumberOfActualParameters() and + ( + none() + or + index = n and result = e.getTransformation() + or + result = e.getActualParameter(index - nTransformation) + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class NotExpression extends @not_expression, UnaryExpression { + override string toString() { result = "NotExpression" } + } + + private Element getImmediateChildOfNotExpression(NotExpression e, int index) { + exists(int n, int nTransformation, int nExpression | + n = 0 and + nTransformation = n + 1 and + nExpression = nTransformation + 1 and + ( + none() + or + index = n and result = e.getTransformation() + or + index = nTransformation and result = e.getExpression() + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class NullLiteralExpression extends @null_literal_expression, LiteralExpression { + override string toString() { result = "NullLiteralExpression" } + } + + private Element getImmediateChildOfNullLiteralExpression(NullLiteralExpression e, int index) { + exists(int n, int nTransformation | + n = 0 and + nTransformation = n + 1 and + ( + none() + or + index = n and result = e.getTransformation() + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class OrExpression extends @or_expression, BinaryExpression { + override string toString() { result = "OrExpression" } + } + + private Element getImmediateChildOfOrExpression(OrExpression e, int index) { + exists(int n, int nTransformation, int nLeft, int nRight | + n = 0 and + nTransformation = n + 1 and + nLeft = nTransformation + 1 and + nRight = nLeft + 1 and + ( + none() + or + index = n and result = e.getTransformation() + or + index = nTransformation and result = e.getLeft() + or + index = nLeft and result = e.getRight() + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class PhysicalAndExpression extends @physical_and_expression, BinaryExpression { + override string toString() { result = "PhysicalAndExpression" } + } + + private Element getImmediateChildOfPhysicalAndExpression(PhysicalAndExpression e, int index) { + exists(int n, int nTransformation, int nLeft, int nRight | + n = 0 and + nTransformation = n + 1 and + nLeft = nTransformation + 1 and + nRight = nLeft + 1 and + ( + none() + or + index = n and result = e.getTransformation() + or + index = nTransformation and result = e.getLeft() + or + index = nLeft and result = e.getRight() + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class PhysicalNotExpression extends @physical_not_expression, UnaryExpression { + override string toString() { result = "PhysicalNotExpression" } + } + + private Element getImmediateChildOfPhysicalNotExpression(PhysicalNotExpression e, int index) { + exists(int n, int nTransformation, int nExpression | + n = 0 and + nTransformation = n + 1 and + nExpression = nTransformation + 1 and + ( + none() + or + index = n and result = e.getTransformation() + or + index = nTransformation and result = e.getExpression() + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class PhysicalOrExpression extends @physical_or_expression, BinaryExpression { + override string toString() { result = "PhysicalOrExpression" } + } + + private Element getImmediateChildOfPhysicalOrExpression(PhysicalOrExpression e, int index) { + exists(int n, int nTransformation, int nLeft, int nRight | + n = 0 and + nTransformation = n + 1 and + nLeft = nTransformation + 1 and + nRight = nLeft + 1 and + ( + none() + or + index = n and result = e.getTransformation() + or + index = nTransformation and result = e.getLeft() + or + index = nLeft and result = e.getRight() + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class PhysicalXorExpression extends @physical_xor_expression, BinaryExpression { + override string toString() { result = "PhysicalXorExpression" } + } + + private Element getImmediateChildOfPhysicalXorExpression(PhysicalXorExpression e, int index) { + exists(int n, int nTransformation, int nLeft, int nRight | + n = 0 and + nTransformation = n + 1 and + nLeft = nTransformation + 1 and + nRight = nLeft + 1 and + ( + none() + or + index = n and result = e.getTransformation() + or + index = nTransformation and result = e.getLeft() + or + index = nLeft and result = e.getRight() + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class ProvidedTypeStaticCall extends @provided_type_static_call, Evaluation { + override string toString() { result = "ProvidedTypeStaticCall" } + + /** + * Gets the method name of this provided type static call, if it exists. + */ + string getMethodName() { provided_type_static_call_method_names(this, result) } + + /** + * Gets the provided type of this provided type static call, if it exists. + */ + ProvidedType getProvidedType() { provided_type_static_call_provided_types(this, result) } + } + + private Element getImmediateChildOfProvidedTypeStaticCall(ProvidedTypeStaticCall e, int index) { + exists(int n, int nTransformation, int nActualParameter, int nProvidedType | + n = 0 and + nTransformation = n + 1 and + nActualParameter = nTransformation + e.getNumberOfActualParameters() and + nProvidedType = nActualParameter + 1 and + ( + none() + or + index = n and result = e.getTransformation() + or + result = e.getActualParameter(index - nTransformation) + or + index = nActualParameter and result = e.getProvidedType() + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class QualifiedStaticFieldExpression extends @qualified_static_field_expression, FieldExpression { + override string toString() { result = "QualifiedStaticFieldExpression" } + + /** + * Gets the class name of this qualified static field expression, if it exists. + */ + string getClassName() { qualified_static_field_expression_class_names(this, result) } + + /** + * Holds if this qualified static field expression is static. + */ + predicate isStatic() { qualified_static_field_expression_is_static(this) } + + /** + * Gets the name of this qualified static field expression, if it exists. + */ + string getName() { qualified_static_field_expression_names(this, result) } + } + + private Element getImmediateChildOfQualifiedStaticFieldExpression( + QualifiedStaticFieldExpression e, int index + ) { + exists(int n, int nTransformation, int nField | + n = 0 and + nTransformation = n + 1 and + nField = nTransformation + 1 and + ( + none() + or + index = n and result = e.getTransformation() + or + index = nTransformation and result = e.getField() + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class QueryModelElement extends @query_model_element, ModelElement { + override string toString() { result = "QueryModelElement" } + + /** + * Holds if this query model element allow cross company. + */ + predicate allowCrossCompany() { query_model_element_allow_cross_company(this) } + + /** + * Gets the behavior of this query model element, if it exists. + */ + Class getBehavior() { query_model_element_behaviors(this, result) } + + /** + * Gets the `index`th data source list of this query model element (0-based). + */ + QueryDataSource getDataSourceList(int index) { + query_model_element_data_source_lists(this, index, result) + } + + /** + * Gets the number of data source lists of this query model element. + */ + int getNumberOfDataSourceLists() { + result = count(int i | query_model_element_data_source_lists(this, i, _)) + } + + /** + * Gets the `index`th data source of this query model element (0-based). + */ + QueryDataSource getDataSource(int index) { + query_model_element_data_sources(this, index, result) + } + + /** + * Gets the number of data sources of this query model element. + */ + int getNumberOfDataSources() { + result = count(int i | query_model_element_data_sources(this, i, _)) + } + + /** + * Gets the element type name of this query model element, if it exists. + */ + string getElementTypeName() { query_model_element_element_type_names(this, result) } + + /** + * Holds if this query model element user update. + */ + predicate userUpdate() { query_model_element_user_update(this) } + } + + private Element getImmediateChildOfQueryModelElement(QueryModelElement e, int index) { + exists( + int n, int nComments, int nRegion, int nBaseMethod, int nExtendGenericParameter, int nMethod, + int nModifierList, int nNestedClass, int nUsing, int nBehavior, int nDataSourceList, + int nDataSource + | + n = 0 and + nComments = n + 1 and + nRegion = nComments + e.getNumberOfRegions() and + nBaseMethod = nRegion + e.getNumberOfBaseMethods() and + nExtendGenericParameter = nBaseMethod + e.getNumberOfExtendGenericParameters() and + nMethod = nExtendGenericParameter + e.getNumberOfMethods() and + nModifierList = nMethod + e.getNumberOfModifierLists() and + nNestedClass = nModifierList + e.getNumberOfNestedClasses() and + nUsing = nNestedClass + e.getNumberOfUsings() and + nBehavior = nUsing + 1 and + nDataSourceList = nBehavior + e.getNumberOfDataSourceLists() and + nDataSource = nDataSourceList + e.getNumberOfDataSources() and + ( + none() + or + index = n and result = e.getComments() + or + result = e.getRegion(index - nComments) + or + result = e.getBaseMethod(index - nRegion) + or + result = e.getExtendGenericParameter(index - nBaseMethod) + or + result = e.getMethod(index - nExtendGenericParameter) + or + result = e.getModifierList(index - nMethod) + or + result = e.getNestedClass(index - nModifierList) + or + result = e.getUsing(index - nNestedClass) + or + index = nUsing and result = e.getBehavior() + or + result = e.getDataSourceList(index - nBehavior) + or + result = e.getDataSource(index - nDataSourceList) + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class RelationalExpression extends @relational_expression, BinaryExpression { + /** + * Gets the operator of this relational expression, if it exists. + */ + string getOperator() { relational_expression_operators(this, result) } + } + + /** + * INTERNAL: Do not use. + */ + class ShiftLeftExpression extends @shift_left_expression, BinaryExpression { + override string toString() { result = "ShiftLeftExpression" } + } + + private Element getImmediateChildOfShiftLeftExpression(ShiftLeftExpression e, int index) { + exists(int n, int nTransformation, int nLeft, int nRight | + n = 0 and + nTransformation = n + 1 and + nLeft = nTransformation + 1 and + nRight = nLeft + 1 and + ( + none() + or + index = n and result = e.getTransformation() + or + index = nTransformation and result = e.getLeft() + or + index = nLeft and result = e.getRight() + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class ShiftRightExpression extends @shift_right_expression, BinaryExpression { + override string toString() { result = "ShiftRightExpression" } + } + + private Element getImmediateChildOfShiftRightExpression(ShiftRightExpression e, int index) { + exists(int n, int nTransformation, int nLeft, int nRight | + n = 0 and + nTransformation = n + 1 and + nLeft = nTransformation + 1 and + nRight = nLeft + 1 and + ( + none() + or + index = n and result = e.getTransformation() + or + index = nTransformation and result = e.getLeft() + or + index = nLeft and result = e.getRight() + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class SimpleQualifierInternal extends @simple_qualifier_internal, SimpleQualifier { + override string toString() { result = "SimpleQualifierInternal" } + } + + private Element getImmediateChildOfSimpleQualifierInternal(SimpleQualifierInternal e, int index) { + none() + } + + /** + * INTERNAL: Do not use. + */ + class StaticQualifier extends @static_qualifier, SimpleQualifier { + override string toString() { result = "StaticQualifier" } + + /** + * Gets the `index`th class type argument list of this static qualifier (0-based). + */ + XppType getClassTypeArgumentList(int index) { + static_qualifier_class_type_argument_lists(this, index, result) + } + + /** + * Gets the number of class type argument lists of this static qualifier. + */ + int getNumberOfClassTypeArgumentLists() { + result = count(int i | static_qualifier_class_type_argument_lists(this, i, _)) + } + } + + private Element getImmediateChildOfStaticQualifier(StaticQualifier e, int index) { + exists(int n, int nClassTypeArgumentList | + n = 0 and + nClassTypeArgumentList = n + e.getNumberOfClassTypeArgumentLists() and + ( + none() + or + result = e.getClassTypeArgumentList(index - n) + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class StringAttributeLiteral extends @string_attribute_literal, DefaultTypeAttributeLiteral { + override string toString() { result = "StringAttributeLiteral" } + } + + private Element getImmediateChildOfStringAttributeLiteral(StringAttributeLiteral e, int index) { + none() + } + + /** + * INTERNAL: Do not use. + */ + class StringLengthType extends @string_length_type, StringType { + override string toString() { result = "StringLengthType" } + + /** + * Gets the edt name of this string length type, if it exists. + */ + string getEdtName() { string_length_type_edt_names(this, result) } + + /** + * Holds if this string length type is edt. + */ + predicate isEdt() { string_length_type_is_edt(this) } + + /** + * Gets the length of this string length type, if it exists. + */ + int getLength() { string_length_type_lengths(this, result) } + } + + private Element getImmediateChildOfStringLengthType(StringLengthType e, int index) { none() } + + /** + * INTERNAL: Do not use. + */ + class StringTypeInternal extends @string_type_internal, StringType { + override string toString() { result = "StringTypeInternal" } + } + + private Element getImmediateChildOfStringTypeInternal(StringTypeInternal e, int index) { none() } + + /** + * INTERNAL: Do not use. + */ + class SubtractExpression extends @subtract_expression, BinaryExpression { + override string toString() { result = "SubtractExpression" } + } + + private Element getImmediateChildOfSubtractExpression(SubtractExpression e, int index) { + exists(int n, int nTransformation, int nLeft, int nRight | + n = 0 and + nTransformation = n + 1 and + nLeft = nTransformation + 1 and + nRight = nLeft + 1 and + ( + none() + or + index = n and result = e.getTransformation() + or + index = nTransformation and result = e.getLeft() + or + index = nLeft and result = e.getRight() + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class SumAggregateSelection extends @sum_aggregate_selection, AggregateSelection { + override string toString() { result = "SumAggregateSelection" } + } + + private Element getImmediateChildOfSumAggregateSelection(SumAggregateSelection e, int index) { + none() + } + + /** + * INTERNAL: Do not use. + */ + class SuperCall extends @super_call, Evaluation { + override string toString() { result = "SuperCall" } + } + + private Element getImmediateChildOfSuperCall(SuperCall e, int index) { + exists(int n, int nTransformation, int nActualParameter | + n = 0 and + nTransformation = n + 1 and + nActualParameter = nTransformation + e.getNumberOfActualParameters() and + ( + none() + or + index = n and result = e.getTransformation() + or + result = e.getActualParameter(index - nTransformation) + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class Table extends @table, ModelElement { + override string toString() { result = "Table" } + + /** + * Gets the attributes of this table, if it exists. + */ + AttributeList getAttributes() { table_attributes(this, result) } + + /** + * Gets the element type name of this table, if it exists. + */ + string getElementTypeName() { table_element_type_names(this, result) } + + /** + * Gets the extends of this table, if it exists. + */ + string getExtends() { table_extends(this, result) } + + /** + * Gets the `index`th field of this table (0-based). + */ + FieldDeclaration getField(int index) { table_fields(this, index, result) } + + /** + * Gets the number of fields of this table. + */ + int getNumberOfFields() { result = count(int i | table_fields(this, i, _)) } + + /** + * Gets the `index`th index of this table (0-based). + */ + string getIndex(int index) { table_indexes(this, index, result) } + + /** + * Gets the number of indexes of this table. + */ + int getNumberOfIndexes() { result = count(int i | table_indexes(this, i, _)) } + + /** + * Holds if this table is aggregate data entity. + */ + predicate isAggregateDataEntity() { table_is_aggregate_data_entity(this) } + + /** + * Holds if this table is data entity view. + */ + predicate isDataEntityView() { table_is_data_entity_view(this) } + + /** + * Holds if this table is map. + */ + predicate isMap() { table_is_map(this) } + + /** + * Holds if this table is updatable. + */ + predicate isUpdatable() { table_is_updatable(this) } + + /** + * Holds if this table is view. + */ + predicate isView() { table_is_view(this) } + + /** + * Holds if this table support inheritance. + */ + predicate supportInheritance() { table_support_inheritance(this) } + } + + private Element getImmediateChildOfTable(Table e, int index) { + exists( + int n, int nComments, int nRegion, int nBaseMethod, int nExtendGenericParameter, int nMethod, + int nModifierList, int nNestedClass, int nUsing, int nAttributes, int nField + | + n = 0 and + nComments = n + 1 and + nRegion = nComments + e.getNumberOfRegions() and + nBaseMethod = nRegion + e.getNumberOfBaseMethods() and + nExtendGenericParameter = nBaseMethod + e.getNumberOfExtendGenericParameters() and + nMethod = nExtendGenericParameter + e.getNumberOfMethods() and + nModifierList = nMethod + e.getNumberOfModifierLists() and + nNestedClass = nModifierList + e.getNumberOfNestedClasses() and + nUsing = nNestedClass + e.getNumberOfUsings() and + nAttributes = nUsing + 1 and + nField = nAttributes + e.getNumberOfFields() and + ( + none() + or + index = n and result = e.getComments() + or + result = e.getRegion(index - nComments) + or + result = e.getBaseMethod(index - nRegion) + or + result = e.getExtendGenericParameter(index - nBaseMethod) + or + result = e.getMethod(index - nExtendGenericParameter) + or + result = e.getModifierList(index - nMethod) + or + result = e.getNestedClass(index - nModifierList) + or + result = e.getUsing(index - nNestedClass) + or + index = nUsing and result = e.getAttributes() + or + result = e.getField(index - nAttributes) + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class TtsAbortStatement extends @tts_abort_statement, TtsStatement { + override string toString() { result = "TtsAbortStatement" } + } + + private Element getImmediateChildOfTtsAbortStatement(TtsAbortStatement e, int index) { none() } + + /** + * INTERNAL: Do not use. + */ + class TtsBeginStatement extends @tts_begin_statement, TtsStatement { + override string toString() { result = "TtsBeginStatement" } + } + + private Element getImmediateChildOfTtsBeginStatement(TtsBeginStatement e, int index) { none() } + + /** + * INTERNAL: Do not use. + */ + class TtsEndStatement extends @tts_end_statement, TtsStatement { + override string toString() { result = "TtsEndStatement" } + } + + private Element getImmediateChildOfTtsEndStatement(TtsEndStatement e, int index) { none() } + + /** + * INTERNAL: Do not use. + */ + class UnaryMinusExpression extends @unary_minus_expression, UnaryExpression { + override string toString() { result = "UnaryMinusExpression" } + } + + private Element getImmediateChildOfUnaryMinusExpression(UnaryMinusExpression e, int index) { + exists(int n, int nTransformation, int nExpression | + n = 0 and + nTransformation = n + 1 and + nExpression = nTransformation + 1 and + ( + none() + or + index = n and result = e.getTransformation() + or + index = nTransformation and result = e.getExpression() + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class AssignPostDecrementStatement extends @assign_post_decrement_statement, AssignmentSingleField + { + override string toString() { result = "AssignPostDecrementStatement" } + } + + private Element getImmediateChildOfAssignPostDecrementStatement( + AssignPostDecrementStatement e, int index + ) { + exists(int n, int nField | + n = 0 and + nField = n + 1 and + ( + none() + or + index = n and result = e.getField() + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class AssignPostIncrementStatement extends @assign_post_increment_statement, AssignmentSingleField + { + override string toString() { result = "AssignPostIncrementStatement" } + } + + private Element getImmediateChildOfAssignPostIncrementStatement( + AssignPostIncrementStatement e, int index + ) { + exists(int n, int nField | + n = 0 and + nField = n + 1 and + ( + none() + or + index = n and result = e.getField() + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class AssignPreDecrementStatement extends @assign_pre_decrement_statement, AssignmentSingleField { + override string toString() { result = "AssignPreDecrementStatement" } + } + + private Element getImmediateChildOfAssignPreDecrementStatement( + AssignPreDecrementStatement e, int index + ) { + exists(int n, int nField | + n = 0 and + nField = n + 1 and + ( + none() + or + index = n and result = e.getField() + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class AssignPreIncrementStatement extends @assign_pre_increment_statement, AssignmentSingleField { + override string toString() { result = "AssignPreIncrementStatement" } + } + + private Element getImmediateChildOfAssignPreIncrementStatement( + AssignPreIncrementStatement e, int index + ) { + exists(int n, int nField | + n = 0 and + nField = n + 1 and + ( + none() + or + index = n and result = e.getField() + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class AssignmentBinary extends @assignment_binary, AssignmentSingleField { + /** + * Gets the expression of this assignment binary, if it exists. + */ + Expression getExpression() { assignment_binary_expressions(this, result) } + } + + /** + * INTERNAL: Do not use. + */ + class AssignmentEventHandlerBase extends @assignment_event_handler_base, AssignmentSingleField { + /** + * Holds if this assignment event handler base addition. + */ + predicate addition() { assignment_event_handler_base_addition(this) } + + /** + * Gets the name of this assignment event handler base, if it exists. + */ + string getName() { assignment_event_handler_base_names(this, result) } + } + + /** + * INTERNAL: Do not use. + */ + class BooleanLiteralExpression extends @boolean_literal_expression, DefaultTypeLiteralExpression { + override string toString() { result = "BooleanLiteralExpression" } + } + + private Element getImmediateChildOfBooleanLiteralExpression(BooleanLiteralExpression e, int index) { + exists(int n, int nTransformation | + n = 0 and + nTransformation = n + 1 and + ( + none() + or + index = n and result = e.getTransformation() + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class Class extends @class, ClassOrInterface { + override string toString() { result = "Class" } + + /** + * Gets the `index`th field of this class (0-based). + */ + FieldDeclaration getField(int index) { class_fields(this, index, result) } + + /** + * Gets the number of fields of this class. + */ + int getNumberOfFields() { result = count(int i | class_fields(this, i, _)) } + + /** + * Holds if this class has cyclic inheritance. + */ + predicate hasCyclicInheritance() { class_has_cyclic_inheritance(this) } + + /** + * Gets the `index`th implement of this class (0-based). + */ + string getImplement(int index) { class_implements(this, index, result) } + + /** + * Gets the number of implements of this class. + */ + int getNumberOfImplements() { result = count(int i | class_implements(this, i, _)) } + } + + private Element getImmediateChildOfClass(Class e, int index) { + exists( + int n, int nComments, int nRegion, int nBaseMethod, int nExtendGenericParameter, int nMethod, + int nModifierList, int nNestedClass, int nUsing, int nAttributes, int nEnclosingType, + int nField + | + n = 0 and + nComments = n + 1 and + nRegion = nComments + e.getNumberOfRegions() and + nBaseMethod = nRegion + e.getNumberOfBaseMethods() and + nExtendGenericParameter = nBaseMethod + e.getNumberOfExtendGenericParameters() and + nMethod = nExtendGenericParameter + e.getNumberOfMethods() and + nModifierList = nMethod + e.getNumberOfModifierLists() and + nNestedClass = nModifierList + e.getNumberOfNestedClasses() and + nUsing = nNestedClass + e.getNumberOfUsings() and + nAttributes = nUsing + 1 and + nEnclosingType = nAttributes + 1 and + nField = nEnclosingType + e.getNumberOfFields() and + ( + none() + or + index = n and result = e.getComments() + or + result = e.getRegion(index - nComments) + or + result = e.getBaseMethod(index - nRegion) + or + result = e.getExtendGenericParameter(index - nBaseMethod) + or + result = e.getMethod(index - nExtendGenericParameter) + or + result = e.getModifierList(index - nMethod) + or + result = e.getNestedClass(index - nModifierList) + or + result = e.getUsing(index - nNestedClass) + or + index = nUsing and result = e.getAttributes() + or + index = nAttributes and result = e.getEnclosingType() + or + result = e.getField(index - nEnclosingType) + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class DateLiteralExpression extends @date_literal_expression, DefaultTypeLiteralExpression { + override string toString() { result = "DateLiteralExpression" } + } + + private Element getImmediateChildOfDateLiteralExpression(DateLiteralExpression e, int index) { + exists(int n, int nTransformation | + n = 0 and + nTransformation = n + 1 and + ( + none() + or + index = n and result = e.getTransformation() + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class DateTimeLiteralExpression extends @date_time_literal_expression, + DefaultTypeLiteralExpression + { + override string toString() { result = "DateTimeLiteralExpression" } + } + + private Element getImmediateChildOfDateTimeLiteralExpression( + DateTimeLiteralExpression e, int index + ) { + exists(int n, int nTransformation | + n = 0 and + nTransformation = n + 1 and + ( + none() + or + index = n and result = e.getTransformation() + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class EqualExpression extends @equal_expression, RelationalExpression { + override string toString() { result = "EqualExpression" } + } + + private Element getImmediateChildOfEqualExpression(EqualExpression e, int index) { + exists(int n, int nTransformation, int nLeft, int nRight | + n = 0 and + nTransformation = n + 1 and + nLeft = nTransformation + 1 and + nRight = nLeft + 1 and + ( + none() + or + index = n and result = e.getTransformation() + or + index = nTransformation and result = e.getLeft() + or + index = nLeft and result = e.getRight() + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class FieldDeclarationInternal extends @field_declaration_internal, FieldDeclaration { + override string toString() { result = "FieldDeclarationInternal" } + } + + private Element getImmediateChildOfFieldDeclarationInternal(FieldDeclarationInternal e, int index) { + exists( + int n, int nComments, int nRegion, int nArraySpecification, int nModifierList, int nType, + int nAttributes, int nInitialValue + | + n = 0 and + nComments = n + 1 and + nRegion = nComments + e.getNumberOfRegions() and + nArraySpecification = nRegion + 1 and + nModifierList = nArraySpecification + e.getNumberOfModifierLists() and + nType = nModifierList + 1 and + nAttributes = nType + 1 and + nInitialValue = nAttributes + 1 and + ( + none() + or + index = n and result = e.getComments() + or + result = e.getRegion(index - nComments) + or + index = nRegion and result = e.getArraySpecification() + or + result = e.getModifierList(index - nArraySpecification) + or + index = nModifierList and result = e.getType() + or + index = nType and result = e.getAttributes() + or + index = nAttributes and result = e.getInitialValue() + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class FormControl extends @form_control, FormNestedElement { + override string toString() { result = "FormControl" } + + /** + * Holds if this form control auto declaration. + */ + predicate autoDeclaration() { form_control_auto_declaration(this) } + + /** + * Gets the `index`th child control of this form control (0-based). + */ + FormControl getChildControl(int index) { form_control_child_controls(this, index, result) } + + /** + * Gets the number of child controls of this form control. + */ + int getNumberOfChildControls() { + result = count(int i | form_control_child_controls(this, i, _)) + } + + /** + * Gets the control class of this form control, if it exists. + */ + string getControlClass() { form_control_control_classes(this, result) } + + /** + * Gets the control type of this form control, if it exists. + */ + string getControlType() { form_control_control_types(this, result) } + + /** + * Gets the custom control class of this form control, if it exists. + */ + string getCustomControlClass() { form_control_custom_control_classes(this, result) } + + /** + * Gets the element type name of this form control, if it exists. + */ + string getElementTypeName() { form_control_element_type_names(this, result) } + + /** + * Gets the internal control name of this form control, if it exists. + */ + string getInternalControlName() { form_control_internal_control_names(this, result) } + + /** + * Holds if this form control is form control extension. + */ + predicate isFormControlExtension() { form_control_is_form_control_extension(this) } + + /** + * Gets the parent control of this form control, if it exists. + */ + FormControl getParentControl() { form_control_parent_controls(this, result) } + } + + private Element getImmediateChildOfFormControl(FormControl e, int index) { + exists( + int n, int nComments, int nRegion, int nBaseMethod, int nExtendGenericParameter, int nMethod, + int nModifierList, int nNestedClass, int nUsing, int nForm, int nChildControl, + int nParentControl + | + n = 0 and + nComments = n + 1 and + nRegion = nComments + e.getNumberOfRegions() and + nBaseMethod = nRegion + e.getNumberOfBaseMethods() and + nExtendGenericParameter = nBaseMethod + e.getNumberOfExtendGenericParameters() and + nMethod = nExtendGenericParameter + e.getNumberOfMethods() and + nModifierList = nMethod + e.getNumberOfModifierLists() and + nNestedClass = nModifierList + e.getNumberOfNestedClasses() and + nUsing = nNestedClass + e.getNumberOfUsings() and + nForm = nUsing + 1 and + nChildControl = nForm + e.getNumberOfChildControls() and + nParentControl = nChildControl + 1 and + ( + none() + or + index = n and result = e.getComments() + or + result = e.getRegion(index - nComments) + or + result = e.getBaseMethod(index - nRegion) + or + result = e.getExtendGenericParameter(index - nBaseMethod) + or + result = e.getMethod(index - nExtendGenericParameter) + or + result = e.getModifierList(index - nMethod) + or + result = e.getNestedClass(index - nModifierList) + or + result = e.getUsing(index - nNestedClass) + or + index = nUsing and result = e.getForm() + or + result = e.getChildControl(index - nForm) + or + index = nChildControl and result = e.getParentControl() + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class FormDataField extends @form_data_field, FormNestedElement { + override string toString() { result = "FormDataField" } + + /** + * Gets the element type name of this form data field, if it exists. + */ + string getElementTypeName() { form_data_field_element_type_names(this, result) } + + /** + * Gets the form data source of this form data field, if it exists. + */ + FormDataSource getFormDataSource() { form_data_field_form_data_sources(this, result) } + } + + private Element getImmediateChildOfFormDataField(FormDataField e, int index) { + exists( + int n, int nComments, int nRegion, int nBaseMethod, int nExtendGenericParameter, int nMethod, + int nModifierList, int nNestedClass, int nUsing, int nForm, int nFormDataSource + | + n = 0 and + nComments = n + 1 and + nRegion = nComments + e.getNumberOfRegions() and + nBaseMethod = nRegion + e.getNumberOfBaseMethods() and + nExtendGenericParameter = nBaseMethod + e.getNumberOfExtendGenericParameters() and + nMethod = nExtendGenericParameter + e.getNumberOfMethods() and + nModifierList = nMethod + e.getNumberOfModifierLists() and + nNestedClass = nModifierList + e.getNumberOfNestedClasses() and + nUsing = nNestedClass + e.getNumberOfUsings() and + nForm = nUsing + 1 and + nFormDataSource = nForm + 1 and + ( + none() + or + index = n and result = e.getComments() + or + result = e.getRegion(index - nComments) + or + result = e.getBaseMethod(index - nRegion) + or + result = e.getExtendGenericParameter(index - nBaseMethod) + or + result = e.getMethod(index - nExtendGenericParameter) + or + result = e.getModifierList(index - nMethod) + or + result = e.getNestedClass(index - nModifierList) + or + result = e.getUsing(index - nNestedClass) + or + index = nUsing and result = e.getForm() + or + index = nForm and result = e.getFormDataSource() + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class FormDataSource extends @form_data_source, FormNestedElement { + override string toString() { result = "FormDataSource" } + + /** + * Gets the `index`th data field of this form data source (0-based). + */ + FormDataField getDataField(int index) { form_data_source_data_fields(this, index, result) } + + /** + * Gets the number of data fields of this form data source. + */ + int getNumberOfDataFields() { result = count(int i | form_data_source_data_fields(this, i, _)) } + + /** + * Gets the element type name of this form data source, if it exists. + */ + string getElementTypeName() { form_data_source_element_type_names(this, result) } + + /** + * Gets the join source of this form data source, if it exists. + */ + string getJoinSource() { form_data_source_join_sources(this, result) } + + /** + * Gets the link type of this form data source, if it exists. + */ + string getLinkType() { form_data_source_link_types(this, result) } + + /** + * Holds if this form data source nested data source. + */ + predicate nestedDataSource() { form_data_source_nested_data_source(this) } + + /** + * Gets the query of this form data source, if it exists. + */ + QueryModelElement getQuery() { form_data_source_queries(this, result) } + + /** + * Gets the query name of this form data source, if it exists. + */ + string getQueryName() { form_data_source_query_names(this, result) } + + /** + * Gets the table of this form data source, if it exists. + */ + string getTable() { form_data_source_tables(this, result) } + } + + private Element getImmediateChildOfFormDataSource(FormDataSource e, int index) { + exists( + int n, int nComments, int nRegion, int nBaseMethod, int nExtendGenericParameter, int nMethod, + int nModifierList, int nNestedClass, int nUsing, int nForm, int nDataField, int nQuery + | + n = 0 and + nComments = n + 1 and + nRegion = nComments + e.getNumberOfRegions() and + nBaseMethod = nRegion + e.getNumberOfBaseMethods() and + nExtendGenericParameter = nBaseMethod + e.getNumberOfExtendGenericParameters() and + nMethod = nExtendGenericParameter + e.getNumberOfMethods() and + nModifierList = nMethod + e.getNumberOfModifierLists() and + nNestedClass = nModifierList + e.getNumberOfNestedClasses() and + nUsing = nNestedClass + e.getNumberOfUsings() and + nForm = nUsing + 1 and + nDataField = nForm + e.getNumberOfDataFields() and + nQuery = nDataField + 1 and + ( + none() + or + index = n and result = e.getComments() + or + result = e.getRegion(index - nComments) + or + result = e.getBaseMethod(index - nRegion) + or + result = e.getExtendGenericParameter(index - nBaseMethod) + or + result = e.getMethod(index - nExtendGenericParameter) + or + result = e.getModifierList(index - nMethod) + or + result = e.getNestedClass(index - nModifierList) + or + result = e.getUsing(index - nNestedClass) + or + index = nUsing and result = e.getForm() + or + result = e.getDataField(index - nForm) + or + index = nDataField and result = e.getQuery() + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class FormElementType extends @form_element_type, NamedType { + override string toString() { result = "FormElementType" } + + /** + * Gets the form name of this form element type, if it exists. + */ + string getFormName() { form_element_type_form_names(this, result) } + } + + private Element getImmediateChildOfFormElementType(FormElementType e, int index) { + exists(int n, int nTypeArgumentList | + n = 0 and + nTypeArgumentList = n + e.getNumberOfTypeArgumentLists() and + ( + none() + or + result = e.getTypeArgumentList(index - n) + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class FunctionCall extends @function_call, GenericEvaluation { + override string toString() { result = "FunctionCall" } + + /** + * Gets the function name of this function call, if it exists. + */ + string getFunctionName() { function_call_function_names(this, result) } + } + + private Element getImmediateChildOfFunctionCall(FunctionCall e, int index) { + exists(int n, int nTransformation, int nActualParameter, int nTypeArgumentList | + n = 0 and + nTransformation = n + 1 and + nActualParameter = nTransformation + e.getNumberOfActualParameters() and + nTypeArgumentList = nActualParameter + e.getNumberOfTypeArgumentLists() and + ( + none() + or + index = n and result = e.getTransformation() + or + result = e.getActualParameter(index - nTransformation) + or + result = e.getTypeArgumentList(index - nActualParameter) + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class FunctionDeclaration extends @function_declaration, LocalDeclaration { + override string toString() { result = "FunctionDeclaration" } + + /** + * Gets the `index`th declarations and statement of this function declaration (0-based). + */ + Statement getDeclarationsAndStatement(int index) { + function_declaration_declarations_and_statements(this, index, result) + } + + /** + * Gets the number of declarations and statements of this function declaration. + */ + int getNumberOfDeclarationsAndStatements() { + result = count(int i | function_declaration_declarations_and_statements(this, i, _)) + } + + /** + * Gets the element type name of this function declaration, if it exists. + */ + string getElementTypeName() { function_declaration_element_type_names(this, result) } + + /** + * Gets the `index`th local of this function declaration (0-based). + */ + LocalDeclaration getLocal(int index) { function_declaration_locals(this, index, result) } + + /** + * Gets the number of locals of this function declaration. + */ + int getNumberOfLocals() { result = count(int i | function_declaration_locals(this, i, _)) } + + /** + * Gets the `index`th parameter of this function declaration (0-based). + */ + ParameterDeclaration getParameter(int index) { + function_declaration_parameters(this, index, result) + } + + /** + * Gets the number of parameters of this function declaration. + */ + int getNumberOfParameters() { + result = count(int i | function_declaration_parameters(this, i, _)) + } + + /** + * Gets the `index`th statement of this function declaration (0-based). + */ + Statement getStatement(int index) { function_declaration_statements(this, index, result) } + + /** + * Gets the number of statements of this function declaration. + */ + int getNumberOfStatements() { + result = count(int i | function_declaration_statements(this, i, _)) + } + } + + private Element getImmediateChildOfFunctionDeclaration(FunctionDeclaration e, int index) { + exists( + int n, int nComments, int nRegion, int nArraySpecification, int nModifierList, int nType, + int nDeclarationsAndStatement, int nLocal, int nParameter, int nStatement + | + n = 0 and + nComments = n + 1 and + nRegion = nComments + e.getNumberOfRegions() and + nArraySpecification = nRegion + 1 and + nModifierList = nArraySpecification + e.getNumberOfModifierLists() and + nType = nModifierList + 1 and + nDeclarationsAndStatement = nType + e.getNumberOfDeclarationsAndStatements() and + nLocal = nDeclarationsAndStatement + e.getNumberOfLocals() and + nParameter = nLocal + e.getNumberOfParameters() and + nStatement = nParameter + e.getNumberOfStatements() and + ( + none() + or + index = n and result = e.getComments() + or + result = e.getRegion(index - nComments) + or + index = nRegion and result = e.getArraySpecification() + or + result = e.getModifierList(index - nArraySpecification) + or + index = nModifierList and result = e.getType() + or + result = e.getDeclarationsAndStatement(index - nType) + or + result = e.getLocal(index - nDeclarationsAndStatement) + or + result = e.getParameter(index - nLocal) + or + result = e.getStatement(index - nParameter) + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class GreaterThanExpression extends @greater_than_expression, RelationalExpression { + override string toString() { result = "GreaterThanExpression" } + } + + private Element getImmediateChildOfGreaterThanExpression(GreaterThanExpression e, int index) { + exists(int n, int nTransformation, int nLeft, int nRight | + n = 0 and + nTransformation = n + 1 and + nLeft = nTransformation + 1 and + nRight = nLeft + 1 and + ( + none() + or + index = n and result = e.getTransformation() + or + index = nTransformation and result = e.getLeft() + or + index = nLeft and result = e.getRight() + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class GreaterThanOrEqualExpression extends @greater_than_or_equal_expression, RelationalExpression + { + override string toString() { result = "GreaterThanOrEqualExpression" } + } + + private Element getImmediateChildOfGreaterThanOrEqualExpression( + GreaterThanOrEqualExpression e, int index + ) { + exists(int n, int nTransformation, int nLeft, int nRight | + n = 0 and + nTransformation = n + 1 and + nLeft = nTransformation + 1 and + nRight = nLeft + 1 and + ( + none() + or + index = n and result = e.getTransformation() + or + index = nTransformation and result = e.getLeft() + or + index = nLeft and result = e.getRight() + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class Int64LiteralExpression extends @int64_literal_expression, DefaultTypeLiteralExpression { + override string toString() { result = "Int64LiteralExpression" } + } + + private Element getImmediateChildOfInt64LiteralExpression(Int64LiteralExpression e, int index) { + exists(int n, int nTransformation | + n = 0 and + nTransformation = n + 1 and + ( + none() + or + index = n and result = e.getTransformation() + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class IntLiteralExpression extends @int_literal_expression, DefaultTypeLiteralExpression { + override string toString() { result = "IntLiteralExpression" } + } + + private Element getImmediateChildOfIntLiteralExpression(IntLiteralExpression e, int index) { + exists(int n, int nTransformation | + n = 0 and + nTransformation = n + 1 and + ( + none() + or + index = n and result = e.getTransformation() + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class Interface extends @interface, ClassOrInterface { + override string toString() { result = "Interface" } + } + + private Element getImmediateChildOfInterface(Interface e, int index) { + exists( + int n, int nComments, int nRegion, int nBaseMethod, int nExtendGenericParameter, int nMethod, + int nModifierList, int nNestedClass, int nUsing, int nAttributes, int nEnclosingType + | + n = 0 and + nComments = n + 1 and + nRegion = nComments + e.getNumberOfRegions() and + nBaseMethod = nRegion + e.getNumberOfBaseMethods() and + nExtendGenericParameter = nBaseMethod + e.getNumberOfExtendGenericParameters() and + nMethod = nExtendGenericParameter + e.getNumberOfMethods() and + nModifierList = nMethod + e.getNumberOfModifierLists() and + nNestedClass = nModifierList + e.getNumberOfNestedClasses() and + nUsing = nNestedClass + e.getNumberOfUsings() and + nAttributes = nUsing + 1 and + nEnclosingType = nAttributes + 1 and + ( + none() + or + index = n and result = e.getComments() + or + result = e.getRegion(index - nComments) + or + result = e.getBaseMethod(index - nRegion) + or + result = e.getExtendGenericParameter(index - nBaseMethod) + or + result = e.getMethod(index - nExtendGenericParameter) + or + result = e.getModifierList(index - nMethod) + or + result = e.getNestedClass(index - nModifierList) + or + result = e.getUsing(index - nNestedClass) + or + index = nUsing and result = e.getAttributes() + or + index = nAttributes and result = e.getEnclosingType() + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class LessThanExpression extends @less_than_expression, RelationalExpression { + override string toString() { result = "LessThanExpression" } + } + + private Element getImmediateChildOfLessThanExpression(LessThanExpression e, int index) { + exists(int n, int nTransformation, int nLeft, int nRight | + n = 0 and + nTransformation = n + 1 and + nLeft = nTransformation + 1 and + nRight = nLeft + 1 and + ( + none() + or + index = n and result = e.getTransformation() + or + index = nTransformation and result = e.getLeft() + or + index = nLeft and result = e.getRight() + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class LessThanOrEqualExpression extends @less_than_or_equal_expression, RelationalExpression { + override string toString() { result = "LessThanOrEqualExpression" } + } + + private Element getImmediateChildOfLessThanOrEqualExpression( + LessThanOrEqualExpression e, int index + ) { + exists(int n, int nTransformation, int nLeft, int nRight | + n = 0 and + nTransformation = n + 1 and + nLeft = nTransformation + 1 and + nRight = nLeft + 1 and + ( + none() + or + index = n and result = e.getTransformation() + or + index = nTransformation and result = e.getLeft() + or + index = nLeft and result = e.getRight() + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class LikeExpression extends @like_expression, RelationalExpression { + override string toString() { result = "LikeExpression" } + } + + private Element getImmediateChildOfLikeExpression(LikeExpression e, int index) { + exists(int n, int nTransformation, int nLeft, int nRight | + n = 0 and + nTransformation = n + 1 and + nLeft = nTransformation + 1 and + nRight = nLeft + 1 and + ( + none() + or + index = n and result = e.getTransformation() + or + index = nTransformation and result = e.getLeft() + or + index = nLeft and result = e.getRight() + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class NamedTypeInternal extends @named_type_internal, NamedType { + override string toString() { result = "NamedTypeInternal" } + } + + private Element getImmediateChildOfNamedTypeInternal(NamedTypeInternal e, int index) { + exists(int n, int nTypeArgumentList | + n = 0 and + nTypeArgumentList = n + e.getNumberOfTypeArgumentLists() and + ( + none() + or + result = e.getTypeArgumentList(index - n) + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class NewClrCall extends @new_clr_call, GenericEvaluation { + override string toString() { result = "NewClrCall" } + + /** + * Gets the clr class name of this new clr call, if it exists. + */ + string getClrClassName() { new_clr_call_clr_class_names(this, result) } + } + + private Element getImmediateChildOfNewClrCall(NewClrCall e, int index) { + exists(int n, int nTransformation, int nActualParameter, int nTypeArgumentList | + n = 0 and + nTransformation = n + 1 and + nActualParameter = nTransformation + e.getNumberOfActualParameters() and + nTypeArgumentList = nActualParameter + e.getNumberOfTypeArgumentLists() and + ( + none() + or + index = n and result = e.getTransformation() + or + result = e.getActualParameter(index - nTransformation) + or + result = e.getTypeArgumentList(index - nActualParameter) + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class NotEqualExpression extends @not_equal_expression, RelationalExpression { + override string toString() { result = "NotEqualExpression" } + } + + private Element getImmediateChildOfNotEqualExpression(NotEqualExpression e, int index) { + exists(int n, int nTransformation, int nLeft, int nRight | + n = 0 and + nTransformation = n + 1 and + nLeft = nTransformation + 1 and + nRight = nLeft + 1 and + ( + none() + or + index = n and result = e.getTransformation() + or + index = nTransformation and result = e.getLeft() + or + index = nLeft and result = e.getRight() + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class QualifiedCall extends @qualified_call, GenericEvaluation { + override string toString() { result = "QualifiedCall" } + + /** + * Gets the method name of this qualified call, if it exists. + */ + string getMethodName() { qualified_call_method_names(this, result) } + + /** + * Gets the qualifier of this qualified call, if it exists. + */ + Qualifier getQualifier() { qualified_call_qualifiers(this, result) } + } + + private Element getImmediateChildOfQualifiedCall(QualifiedCall e, int index) { + exists(int n, int nTransformation, int nActualParameter, int nTypeArgumentList, int nQualifier | + n = 0 and + nTransformation = n + 1 and + nActualParameter = nTransformation + e.getNumberOfActualParameters() and + nTypeArgumentList = nActualParameter + e.getNumberOfTypeArgumentLists() and + nQualifier = nTypeArgumentList + 1 and + ( + none() + or + index = n and result = e.getTransformation() + or + result = e.getActualParameter(index - nTransformation) + or + result = e.getTypeArgumentList(index - nActualParameter) + or + index = nTypeArgumentList and result = e.getQualifier() + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class QualifiedStaticCall extends @qualified_static_call, GenericEvaluation { + override string toString() { result = "QualifiedStaticCall" } + + /** + * Gets the class name of this qualified static call, if it exists. + */ + string getClassName() { qualified_static_call_class_names(this, result) } + + /** + * Gets the `index`th class type argument list of this qualified static call (0-based). + */ + XppType getClassTypeArgumentList(int index) { + qualified_static_call_class_type_argument_lists(this, index, result) + } + + /** + * Gets the number of class type argument lists of this qualified static call. + */ + int getNumberOfClassTypeArgumentLists() { + result = count(int i | qualified_static_call_class_type_argument_lists(this, i, _)) + } + + /** + * Holds if this qualified static call is table map call. + */ + predicate isTableMapCall() { qualified_static_call_is_table_map_call(this) } + + /** + * Gets the method name of this qualified static call, if it exists. + */ + string getMethodName() { qualified_static_call_method_names(this, result) } + + /** + * Gets the qualifier of this qualified static call, if it exists. + */ + Qualifier getQualifier() { qualified_static_call_qualifiers(this, result) } + } + + private Element getImmediateChildOfQualifiedStaticCall(QualifiedStaticCall e, int index) { + exists( + int n, int nTransformation, int nActualParameter, int nTypeArgumentList, + int nClassTypeArgumentList, int nQualifier + | + n = 0 and + nTransformation = n + 1 and + nActualParameter = nTransformation + e.getNumberOfActualParameters() and + nTypeArgumentList = nActualParameter + e.getNumberOfTypeArgumentLists() and + nClassTypeArgumentList = nTypeArgumentList + e.getNumberOfClassTypeArgumentLists() and + nQualifier = nClassTypeArgumentList + 1 and + ( + none() + or + index = n and result = e.getTransformation() + or + result = e.getActualParameter(index - nTransformation) + or + result = e.getTypeArgumentList(index - nActualParameter) + or + result = e.getClassTypeArgumentList(index - nTypeArgumentList) + or + index = nClassTypeArgumentList and result = e.getQualifier() + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class RealLiteralExpression extends @real_literal_expression, DefaultTypeLiteralExpression { + override string toString() { result = "RealLiteralExpression" } + } + + private Element getImmediateChildOfRealLiteralExpression(RealLiteralExpression e, int index) { + exists(int n, int nTransformation | + n = 0 and + nTransformation = n + 1 and + ( + none() + or + index = n and result = e.getTransformation() + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class StaticMethodCall extends @static_method_call, GenericEvaluation { + override string toString() { result = "StaticMethodCall" } + + /** + * Gets the class name of this static method call, if it exists. + */ + string getClassName() { static_method_call_class_names(this, result) } + + /** + * Gets the `index`th class type argument list of this static method call (0-based). + */ + XppType getClassTypeArgumentList(int index) { + static_method_call_class_type_argument_lists(this, index, result) + } + + /** + * Gets the number of class type argument lists of this static method call. + */ + int getNumberOfClassTypeArgumentLists() { + result = count(int i | static_method_call_class_type_argument_lists(this, i, _)) + } + + /** + * Gets the method name of this static method call, if it exists. + */ + string getMethodName() { static_method_call_method_names(this, result) } + } + + private Element getImmediateChildOfStaticMethodCall(StaticMethodCall e, int index) { + exists( + int n, int nTransformation, int nActualParameter, int nTypeArgumentList, + int nClassTypeArgumentList + | + n = 0 and + nTransformation = n + 1 and + nActualParameter = nTransformation + e.getNumberOfActualParameters() and + nTypeArgumentList = nActualParameter + e.getNumberOfTypeArgumentLists() and + nClassTypeArgumentList = nTypeArgumentList + e.getNumberOfClassTypeArgumentLists() and + ( + none() + or + index = n and result = e.getTransformation() + or + result = e.getActualParameter(index - nTransformation) + or + result = e.getTypeArgumentList(index - nActualParameter) + or + result = e.getClassTypeArgumentList(index - nTypeArgumentList) + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class StringLiteralExpression extends @string_literal_expression, DefaultTypeLiteralExpression { + override string toString() { result = "StringLiteralExpression" } + + /** + * Holds if this string literal expression is label. + */ + predicate isLabel() { string_literal_expression_is_label(this) } + + /** + * Gets the label file of this string literal expression, if it exists. + */ + string getLabelFileId() { string_literal_expression_label_file_ids(this, result) } + + /** + * Gets the label of this string literal expression, if it exists. + */ + string getLabelId() { string_literal_expression_label_ids(this, result) } + } + + private Element getImmediateChildOfStringLiteralExpression(StringLiteralExpression e, int index) { + exists(int n, int nTransformation | + n = 0 and + nTransformation = n + 1 and + ( + none() + or + index = n and result = e.getTransformation() + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class TableFieldDeclaration extends @table_field_declaration, FieldDeclaration { + override string toString() { result = "TableFieldDeclaration" } + } + + private Element getImmediateChildOfTableFieldDeclaration(TableFieldDeclaration e, int index) { + exists( + int n, int nComments, int nRegion, int nArraySpecification, int nModifierList, int nType, + int nAttributes, int nInitialValue + | + n = 0 and + nComments = n + 1 and + nRegion = nComments + e.getNumberOfRegions() and + nArraySpecification = nRegion + 1 and + nModifierList = nArraySpecification + e.getNumberOfModifierLists() and + nType = nModifierList + 1 and + nAttributes = nType + 1 and + nInitialValue = nAttributes + 1 and + ( + none() + or + index = n and result = e.getComments() + or + result = e.getRegion(index - nComments) + or + index = nRegion and result = e.getArraySpecification() + or + result = e.getModifierList(index - nArraySpecification) + or + index = nModifierList and result = e.getType() + or + index = nType and result = e.getAttributes() + or + index = nAttributes and result = e.getInitialValue() + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class VariableDeclaration extends @variable_declaration, LocalDeclaration { + /** + * Gets the element type name of this variable declaration, if it exists. + */ + string getElementTypeName() { variable_declaration_element_type_names(this, result) } + + /** + * Gets the initial value of this variable declaration, if it exists. + */ + Expression getInitialValue() { variable_declaration_initial_values(this, result) } + + /** + * Holds if this variable declaration is const. + */ + predicate isConst() { variable_declaration_is_const(this) } + } + + /** + * INTERNAL: Do not use. + */ + class AssignDecrementStatement extends @assign_decrement_statement, AssignmentBinary { + override string toString() { result = "AssignDecrementStatement" } + } + + private Element getImmediateChildOfAssignDecrementStatement(AssignDecrementStatement e, int index) { + exists(int n, int nField, int nExpression | + n = 0 and + nField = n + 1 and + nExpression = nField + 1 and + ( + none() + or + index = n and result = e.getField() + or + index = nField and result = e.getExpression() + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class AssignDivideStatement extends @assign_divide_statement, AssignmentBinary { + override string toString() { result = "AssignDivideStatement" } + } + + private Element getImmediateChildOfAssignDivideStatement(AssignDivideStatement e, int index) { + exists(int n, int nField, int nExpression | + n = 0 and + nField = n + 1 and + nExpression = nField + 1 and + ( + none() + or + index = n and result = e.getField() + or + index = nField and result = e.getExpression() + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class AssignEqualStatement extends @assign_equal_statement, AssignmentBinary { + override string toString() { result = "AssignEqualStatement" } + } + + private Element getImmediateChildOfAssignEqualStatement(AssignEqualStatement e, int index) { + exists(int n, int nField, int nExpression | + n = 0 and + nField = n + 1 and + nExpression = nField + 1 and + ( + none() + or + index = n and result = e.getField() + or + index = nField and result = e.getExpression() + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class AssignIncrementStatement extends @assign_increment_statement, AssignmentBinary { + override string toString() { result = "AssignIncrementStatement" } + } + + private Element getImmediateChildOfAssignIncrementStatement(AssignIncrementStatement e, int index) { + exists(int n, int nField, int nExpression | + n = 0 and + nField = n + 1 and + nExpression = nField + 1 and + ( + none() + or + index = n and result = e.getField() + or + index = nField and result = e.getExpression() + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class AssignMultiplyStatement extends @assign_multiply_statement, AssignmentBinary { + override string toString() { result = "AssignMultiplyStatement" } + } + + private Element getImmediateChildOfAssignMultiplyStatement(AssignMultiplyStatement e, int index) { + exists(int n, int nField, int nExpression | + n = 0 and + nField = n + 1 and + nExpression = nField + 1 and + ( + none() + or + index = n and result = e.getField() + or + index = nField and result = e.getExpression() + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class AssignmentEventHandlerInstance extends @assignment_event_handler_instance, + AssignmentEventHandlerBase + { + override string toString() { result = "AssignmentEventHandlerInstance" } + + /** + * Gets the qualifier part of this assignment event handler instance, if it exists. + */ + Qualifier getQualifierPart() { assignment_event_handler_instance_qualifier_parts(this, result) } + } + + private Element getImmediateChildOfAssignmentEventHandlerInstance( + AssignmentEventHandlerInstance e, int index + ) { + exists(int n, int nField, int nQualifierPart | + n = 0 and + nField = n + 1 and + nQualifierPart = nField + 1 and + ( + none() + or + index = n and result = e.getField() + or + index = nField and result = e.getQualifierPart() + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class AssignmentEventHandlerStatic extends @assignment_event_handler_static, + AssignmentEventHandlerBase + { + /** + * Gets the type name of this assignment event handler static, if it exists. + */ + string getTypeName() { assignment_event_handler_static_type_names(this, result) } + } + + /** + * INTERNAL: Do not use. + */ + class ParameterDeclaration extends @parameter_declaration, VariableDeclaration { + override string toString() { result = "ParameterDeclaration" } + + /** + * Holds if this parameter declaration is by reference. + */ + predicate isByRef() { parameter_declaration_is_by_ref(this) } + + /** + * Holds if this parameter declaration is optional. + */ + predicate isOptional() { parameter_declaration_is_optional(this) } + } + + private Element getImmediateChildOfParameterDeclaration(ParameterDeclaration e, int index) { + exists( + int n, int nComments, int nRegion, int nArraySpecification, int nModifierList, int nType, + int nInitialValue + | + n = 0 and + nComments = n + 1 and + nRegion = nComments + e.getNumberOfRegions() and + nArraySpecification = nRegion + 1 and + nModifierList = nArraySpecification + e.getNumberOfModifierLists() and + nType = nModifierList + 1 and + nInitialValue = nType + 1 and + ( + none() + or + index = n and result = e.getComments() + or + result = e.getRegion(index - nComments) + or + index = nRegion and result = e.getArraySpecification() + or + result = e.getModifierList(index - nArraySpecification) + or + index = nModifierList and result = e.getType() + or + index = nType and result = e.getInitialValue() + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class VariableDeclarationInternal extends @variable_declaration_internal, VariableDeclaration { + override string toString() { result = "VariableDeclarationInternal" } + } + + private Element getImmediateChildOfVariableDeclarationInternal( + VariableDeclarationInternal e, int index + ) { + exists( + int n, int nComments, int nRegion, int nArraySpecification, int nModifierList, int nType, + int nInitialValue + | + n = 0 and + nComments = n + 1 and + nRegion = nComments + e.getNumberOfRegions() and + nArraySpecification = nRegion + 1 and + nModifierList = nArraySpecification + e.getNumberOfModifierLists() and + nType = nModifierList + 1 and + nInitialValue = nType + 1 and + ( + none() + or + index = n and result = e.getComments() + or + result = e.getRegion(index - nComments) + or + index = nRegion and result = e.getArraySpecification() + or + result = e.getModifierList(index - nArraySpecification) + or + index = nModifierList and result = e.getType() + or + index = nType and result = e.getInitialValue() + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class AssignmentEventHandlerClr extends @assignment_event_handler_clr, + AssignmentEventHandlerStatic + { + override string toString() { result = "AssignmentEventHandlerClr" } + } + + private Element getImmediateChildOfAssignmentEventHandlerClr( + AssignmentEventHandlerClr e, int index + ) { + exists(int n, int nField | + n = 0 and + nField = n + 1 and + ( + none() + or + index = n and result = e.getField() + ) + ) + } + + /** + * INTERNAL: Do not use. + */ + class AssignmentEventHandlerStaticInternal extends @assignment_event_handler_static_internal, + AssignmentEventHandlerStatic + { + override string toString() { result = "AssignmentEventHandlerStaticInternal" } + } + + private Element getImmediateChildOfAssignmentEventHandlerStaticInternal( + AssignmentEventHandlerStaticInternal e, int index + ) { + exists(int n, int nField | + n = 0 and + nField = n + 1 and + ( + none() + or + index = n and result = e.getField() + ) + ) + } + + /** + * Gets the immediate child indexed at `index`. Indexes are not guaranteed to be contiguous, but are guaranteed to be distinct. + */ + pragma[nomagic] + Element getImmediateChild(Element e, int index) { + // why does this look more complicated than it should? + // * none() simplifies generation, as we can append `or ...` without a special case for the first item + none() + or + result = getImmediateChildOfFile(e, index) + or + result = getImmediateChildOfLocation(e, index) + or + result = getImmediateChildOfComment(e, index) + or + result = getImmediateChildOfArraySpecification(e, index) + or + result = getImmediateChildOfAttribute(e, index) + or + result = getImmediateChildOfAttributeExpression(e, index) + or + result = getImmediateChildOfAttributeList(e, index) + or + result = getImmediateChildOfAttributeNamedParameterEntry(e, index) + or + result = getImmediateChildOfClassAccessModifier(e, index) + or + result = getImmediateChildOfCompilationUnitRegionEntry(e, index) + or + result = getImmediateChildOfEvaluationActualParameterEntry(e, index) + or + result = getImmediateChildOfFieldAssignment(e, index) + or + result = getImmediateChildOfInsertFieldSpecification(e, index) + or + result = getImmediateChildOfJoinSpecification(e, index) + or + result = getImmediateChildOfModelElementUsingEntry(e, index) + or + result = getImmediateChildOfModifier(e, index) + or + result = getImmediateChildOfQuery(e, index) + or + result = getImmediateChildOfQueryDataSource(e, index) + or + result = getImmediateChildOfQueryDataSourceHaving(e, index) + or + result = getImmediateChildOfQueryDataSourceRange(e, index) + or + result = getImmediateChildOfQueryDataSourceRelation(e, index) + or + result = getImmediateChildOfSwitchCase(e, index) + or + result = getImmediateChildOfSwitchStatementCaseEntry(e, index) + or + result = getImmediateChildOfTryStatementCatchEntry(e, index) + or + result = getImmediateChildOfUnspecifiedElement(e, index) + or + result = getImmediateChildOfAllFieldsSelection(e, index) + or + result = getImmediateChildOfAnyType(e, index) + or + result = getImmediateChildOfBooleanType(e, index) + or + result = getImmediateChildOfBreakStatement(e, index) + or + result = getImmediateChildOfBreakpointStatement(e, index) + or + result = getImmediateChildOfCaseDefault(e, index) + or + result = getImmediateChildOfCaseValues(e, index) + or + result = getImmediateChildOfCatchAllValues(e, index) + or + result = getImmediateChildOfCatchExpression(e, index) + or + result = getImmediateChildOfCatchUpdateConflict(e, index) + or + result = getImmediateChildOfCompoundStatement(e, index) + or + result = getImmediateChildOfConditionalExpression(e, index) + or + result = getImmediateChildOfContainerAttributeLiteral(e, index) + or + result = getImmediateChildOfContainerType(e, index) + or + result = getImmediateChildOfContinueStatement(e, index) + or + result = getImmediateChildOfCrossCompanyAll(e, index) + or + result = getImmediateChildOfCrossCompanyContainer(e, index) + or + result = getImmediateChildOfDateTimeType(e, index) + or + result = getImmediateChildOfDateType(e, index) + or + result = getImmediateChildOfDblType(e, index) + or + result = getImmediateChildOfDeleteStatement(e, index) + or + result = getImmediateChildOfDoWhileStatement(e, index) + or + result = getImmediateChildOfEmptyExpression(e, index) + or + result = getImmediateChildOfEmptyStatement(e, index) + or + result = getImmediateChildOfEnumAttributeLiteral(e, index) + or + result = getImmediateChildOfEnumerationType(e, index) + or + result = getImmediateChildOfExplicitSelection(e, index) + or + result = getImmediateChildOfExpressionCompilationUnit(e, index) + or + result = getImmediateChildOfExpressionQualifier(e, index) + or + result = getImmediateChildOfExpressionStatement(e, index) + or + result = getImmediateChildOfFieldSelection(e, index) + or + result = getImmediateChildOfFindStatement(e, index) + or + result = getImmediateChildOfFlushStatement(e, index) + or + result = getImmediateChildOfForDeclarationAssign(e, index) + or + result = getImmediateChildOfForFieldPostDecrement(e, index) + or + result = getImmediateChildOfForFieldPostIncrement(e, index) + or + result = getImmediateChildOfForFieldPreDecrement(e, index) + or + result = getImmediateChildOfForFieldPreIncrement(e, index) + or + result = getImmediateChildOfForStatement(e, index) + or + result = getImmediateChildOfGlobalOrderElement(e, index) + or + result = getImmediateChildOfGuidType(e, index) + or + result = getImmediateChildOfIfStatement(e, index) + or + result = getImmediateChildOfIfThenElseStatement(e, index) + or + result = getImmediateChildOfImplicitSelection(e, index) + or + result = getImmediateChildOfInsertStatement(e, index) + or + result = getImmediateChildOfInt64Type(e, index) + or + result = getImmediateChildOfIntType(e, index) + or + result = getImmediateChildOfIntrinsic(e, index) + or + result = getImmediateChildOfIntrinsicAttributeLiteral(e, index) + or + result = getImmediateChildOfLocalDeclarationsStatement(e, index) + or + result = getImmediateChildOfMoveCursorStatement(e, index) + or + result = getImmediateChildOfNamedFieldReference(e, index) + or + result = getImmediateChildOfNewClrArrayExpression(e, index) + or + result = getImmediateChildOfNumberedFieldReference(e, index) + or + result = getImmediateChildOfPlaceholder(e, index) + or + result = getImmediateChildOfPrintStatement(e, index) + or + result = getImmediateChildOfProvidedType(e, index) + or + result = getImmediateChildOfQualifiedField(e, index) + or + result = getImmediateChildOfQualifiedInstanceName(e, index) + or + result = getImmediateChildOfQualifiedNumberedField(e, index) + or + result = getImmediateChildOfQualifiedStaticField(e, index) + or + result = getImmediateChildOfRetryStatement(e, index) + or + result = getImmediateChildOfReturnStatement(e, index) + or + result = getImmediateChildOfSearchStatement(e, index) + or + result = getImmediateChildOfSimpleField(e, index) + or + result = getImmediateChildOfSimpleInstanceName(e, index) + or + result = getImmediateChildOfSimpleOrderElement(e, index) + or + result = getImmediateChildOfStaticField(e, index) + or + result = getImmediateChildOfSwitchStatement(e, index) + or + result = getImmediateChildOfTableLookupExpression(e, index) + or + result = getImmediateChildOfThrowStatement(e, index) + or + result = getImmediateChildOfTryStatement(e, index) + or + result = getImmediateChildOfUncheckedStatement(e, index) + or + result = getImmediateChildOfUpdateStatement(e, index) + or + result = getImmediateChildOfUsingStatement(e, index) + or + result = getImmediateChildOfValidTimeStateDate(e, index) + or + result = getImmediateChildOfValidTimeStateRange(e, index) + or + result = getImmediateChildOfVarType(e, index) + or + result = getImmediateChildOfVoidType(e, index) + or + result = getImmediateChildOfWhileStatement(e, index) + or + result = getImmediateChildOfXppTypeCompilationUnit(e, index) + or + result = getImmediateChildOfAddExpression(e, index) + or + result = getImmediateChildOfAndExpression(e, index) + or + result = getImmediateChildOfAsClrExpression(e, index) + or + result = getImmediateChildOfAsExpression(e, index) + or + result = getImmediateChildOfAssignMultipleFieldStatement(e, index) + or + result = getImmediateChildOfAvgAggregateSelection(e, index) + or + result = getImmediateChildOfBooleanAttributeLiteral(e, index) + or + result = getImmediateChildOfChangeCompanyStatement(e, index) + or + result = getImmediateChildOfClrEnumerationLiteralExpression(e, index) + or + result = getImmediateChildOfClrType(e, index) + or + result = getImmediateChildOfContainerLiteralExpression(e, index) + or + result = getImmediateChildOfCountAggregateSelection(e, index) + or + result = getImmediateChildOfDateAttributeLiteral(e, index) + or + result = getImmediateChildOfDateTimeAttributeLiteral(e, index) + or + result = getImmediateChildOfDblAttributeLiteral(e, index) + or + result = getImmediateChildOfDelegate(e, index) + or + result = getImmediateChildOfDivideExpression(e, index) + or + result = getImmediateChildOfEnumerationLiteralExpression(e, index) + or + result = getImmediateChildOfFieldExpressionInternal(e, index) + or + result = getImmediateChildOfForFieldAssign(e, index) + or + result = getImmediateChildOfForFieldDecrementAssign(e, index) + or + result = getImmediateChildOfForFieldIncrementAssign(e, index) + or + result = getImmediateChildOfFormModelElement(e, index) + or + result = getImmediateChildOfGuidAttributeLiteral(e, index) + or + result = getImmediateChildOfInExpression(e, index) + or + result = getImmediateChildOfInt64AttributeLiteral(e, index) + or + result = getImmediateChildOfIntAttributeLiteral(e, index) + or + result = getImmediateChildOfIntegerDivideExpression(e, index) + or + result = getImmediateChildOfIsClrExpression(e, index) + or + result = getImmediateChildOfIsExpression(e, index) + or + result = getImmediateChildOfMaxAggregateSelection(e, index) + or + result = getImmediateChildOfMethod(e, index) + or + result = getImmediateChildOfMinAggregateSelection(e, index) + or + result = getImmediateChildOfModExpression(e, index) + or + result = getImmediateChildOfMultiplyExpression(e, index) + or + result = getImmediateChildOfNewCall(e, index) + or + result = getImmediateChildOfNextExpression(e, index) + or + result = getImmediateChildOfNotExpression(e, index) + or + result = getImmediateChildOfNullLiteralExpression(e, index) + or + result = getImmediateChildOfOrExpression(e, index) + or + result = getImmediateChildOfPhysicalAndExpression(e, index) + or + result = getImmediateChildOfPhysicalNotExpression(e, index) + or + result = getImmediateChildOfPhysicalOrExpression(e, index) + or + result = getImmediateChildOfPhysicalXorExpression(e, index) + or + result = getImmediateChildOfProvidedTypeStaticCall(e, index) + or + result = getImmediateChildOfQualifiedStaticFieldExpression(e, index) + or + result = getImmediateChildOfQueryModelElement(e, index) + or + result = getImmediateChildOfShiftLeftExpression(e, index) + or + result = getImmediateChildOfShiftRightExpression(e, index) + or + result = getImmediateChildOfSimpleQualifierInternal(e, index) + or + result = getImmediateChildOfStaticQualifier(e, index) + or + result = getImmediateChildOfStringAttributeLiteral(e, index) + or + result = getImmediateChildOfStringLengthType(e, index) + or + result = getImmediateChildOfStringTypeInternal(e, index) + or + result = getImmediateChildOfSubtractExpression(e, index) + or + result = getImmediateChildOfSumAggregateSelection(e, index) + or + result = getImmediateChildOfSuperCall(e, index) + or + result = getImmediateChildOfTable(e, index) + or + result = getImmediateChildOfTtsAbortStatement(e, index) + or + result = getImmediateChildOfTtsBeginStatement(e, index) + or + result = getImmediateChildOfTtsEndStatement(e, index) + or + result = getImmediateChildOfUnaryMinusExpression(e, index) + or + result = getImmediateChildOfAssignPostDecrementStatement(e, index) + or + result = getImmediateChildOfAssignPostIncrementStatement(e, index) + or + result = getImmediateChildOfAssignPreDecrementStatement(e, index) + or + result = getImmediateChildOfAssignPreIncrementStatement(e, index) + or + result = getImmediateChildOfBooleanLiteralExpression(e, index) + or + result = getImmediateChildOfClass(e, index) + or + result = getImmediateChildOfDateLiteralExpression(e, index) + or + result = getImmediateChildOfDateTimeLiteralExpression(e, index) + or + result = getImmediateChildOfEqualExpression(e, index) + or + result = getImmediateChildOfFieldDeclarationInternal(e, index) + or + result = getImmediateChildOfFormControl(e, index) + or + result = getImmediateChildOfFormDataField(e, index) + or + result = getImmediateChildOfFormDataSource(e, index) + or + result = getImmediateChildOfFormElementType(e, index) + or + result = getImmediateChildOfFunctionCall(e, index) + or + result = getImmediateChildOfFunctionDeclaration(e, index) + or + result = getImmediateChildOfGreaterThanExpression(e, index) + or + result = getImmediateChildOfGreaterThanOrEqualExpression(e, index) + or + result = getImmediateChildOfInt64LiteralExpression(e, index) + or + result = getImmediateChildOfIntLiteralExpression(e, index) + or + result = getImmediateChildOfInterface(e, index) + or + result = getImmediateChildOfLessThanExpression(e, index) + or + result = getImmediateChildOfLessThanOrEqualExpression(e, index) + or + result = getImmediateChildOfLikeExpression(e, index) + or + result = getImmediateChildOfNamedTypeInternal(e, index) + or + result = getImmediateChildOfNewClrCall(e, index) + or + result = getImmediateChildOfNotEqualExpression(e, index) + or + result = getImmediateChildOfQualifiedCall(e, index) + or + result = getImmediateChildOfQualifiedStaticCall(e, index) + or + result = getImmediateChildOfRealLiteralExpression(e, index) + or + result = getImmediateChildOfStaticMethodCall(e, index) + or + result = getImmediateChildOfStringLiteralExpression(e, index) + or + result = getImmediateChildOfTableFieldDeclaration(e, index) + or + result = getImmediateChildOfAssignDecrementStatement(e, index) + or + result = getImmediateChildOfAssignDivideStatement(e, index) + or + result = getImmediateChildOfAssignEqualStatement(e, index) + or + result = getImmediateChildOfAssignIncrementStatement(e, index) + or + result = getImmediateChildOfAssignMultiplyStatement(e, index) + or + result = getImmediateChildOfAssignmentEventHandlerInstance(e, index) + or + result = getImmediateChildOfParameterDeclaration(e, index) + or + result = getImmediateChildOfVariableDeclarationInternal(e, index) + or + result = getImmediateChildOfAssignmentEventHandlerClr(e, index) + or + result = getImmediateChildOfAssignmentEventHandlerStaticInternal(e, index) + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/RealLiteralExpression.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/RealLiteralExpression.qll new file mode 100644 index 000000000000..a4a1720ba0e9 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/RealLiteralExpression.qll @@ -0,0 +1,25 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `RealLiteralExpression`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.DefaultTypeLiteralExpressionImpl::Impl as DefaultTypeLiteralExpressionImpl + +/** + * INTERNAL: This module contains the fully generated definition of `RealLiteralExpression` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::RealLiteralExpression` class directly. + * Use the subclass `RealLiteralExpression`, where the following predicates are available. + */ + class RealLiteralExpression extends Synth::TRealLiteralExpression, + DefaultTypeLiteralExpressionImpl::DefaultTypeLiteralExpression + { + override string getAPrimaryQlClass() { result = "RealLiteralExpression" } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/RelationalExpression.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/RelationalExpression.qll new file mode 100644 index 000000000000..9961e1ff8b47 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/RelationalExpression.qll @@ -0,0 +1,36 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `RelationalExpression`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.BinaryExpressionImpl::Impl as BinaryExpressionImpl + +/** + * INTERNAL: This module contains the fully generated definition of `RelationalExpression` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::RelationalExpression` class directly. + * Use the subclass `RelationalExpression`, where the following predicates are available. + */ + class RelationalExpression extends Synth::TRelationalExpression, + BinaryExpressionImpl::BinaryExpression + { + /** + * Gets the operator of this relational expression, if it exists. + */ + string getOperator() { + result = + Synth::convertRelationalExpressionToRaw(this).(Raw::RelationalExpression).getOperator() + } + + /** + * Holds if `getOperator()` exists. + */ + final predicate hasOperator() { exists(this.getOperator()) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/RetryStatement.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/RetryStatement.qll new file mode 100644 index 000000000000..0b93665e7c87 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/RetryStatement.qll @@ -0,0 +1,23 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `RetryStatement`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.StatementImpl::Impl as StatementImpl + +/** + * INTERNAL: This module contains the fully generated definition of `RetryStatement` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::RetryStatement` class directly. + * Use the subclass `RetryStatement`, where the following predicates are available. + */ + class RetryStatement extends Synth::TRetryStatement, StatementImpl::Statement { + override string getAPrimaryQlClass() { result = "RetryStatement" } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/ReturnStatement.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/ReturnStatement.qll new file mode 100644 index 000000000000..de0ca51285ae --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/ReturnStatement.qll @@ -0,0 +1,39 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `ReturnStatement`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.Expression +import codeql.xpp.elements.internal.StatementImpl::Impl as StatementImpl + +/** + * INTERNAL: This module contains the fully generated definition of `ReturnStatement` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::ReturnStatement` class directly. + * Use the subclass `ReturnStatement`, where the following predicates are available. + */ + class ReturnStatement extends Synth::TReturnStatement, StatementImpl::Statement { + override string getAPrimaryQlClass() { result = "ReturnStatement" } + + /** + * Gets the expression of this return statement, if it exists. + */ + Expression getExpression() { + result = + Synth::convertExpressionFromRaw(Synth::convertReturnStatementToRaw(this) + .(Raw::ReturnStatement) + .getExpression()) + } + + /** + * Holds if `getExpression()` exists. + */ + final predicate hasExpression() { exists(this.getExpression()) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/SearchStatement.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/SearchStatement.qll new file mode 100644 index 000000000000..2713dd1d5e58 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/SearchStatement.qll @@ -0,0 +1,55 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `SearchStatement`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.Query +import codeql.xpp.elements.Statement +import codeql.xpp.elements.internal.StatementImpl::Impl as StatementImpl + +/** + * INTERNAL: This module contains the fully generated definition of `SearchStatement` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::SearchStatement` class directly. + * Use the subclass `SearchStatement`, where the following predicates are available. + */ + class SearchStatement extends Synth::TSearchStatement, StatementImpl::Statement { + override string getAPrimaryQlClass() { result = "SearchStatement" } + + /** + * Gets the query of this search statement, if it exists. + */ + Query getQuery() { + result = + Synth::convertQueryFromRaw(Synth::convertSearchStatementToRaw(this) + .(Raw::SearchStatement) + .getQuery()) + } + + /** + * Holds if `getQuery()` exists. + */ + final predicate hasQuery() { exists(this.getQuery()) } + + /** + * Gets the statement of this search statement, if it exists. + */ + Statement getStatement() { + result = + Synth::convertStatementFromRaw(Synth::convertSearchStatementToRaw(this) + .(Raw::SearchStatement) + .getStatement()) + } + + /** + * Holds if `getStatement()` exists. + */ + final predicate hasStatement() { exists(this.getStatement()) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/Selection.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/Selection.qll new file mode 100644 index 000000000000..0f977b624968 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/Selection.qll @@ -0,0 +1,21 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `Selection`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.AstImpl::Impl as AstImpl + +/** + * INTERNAL: This module contains the fully generated definition of `Selection` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::Selection` class directly. + * Use the subclass `Selection`, where the following predicates are available. + */ + class Selection extends Synth::TSelection, AstImpl::Ast { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/SelectionField.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/SelectionField.qll new file mode 100644 index 000000000000..845a9353489d --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/SelectionField.qll @@ -0,0 +1,45 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `SelectionField`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.AstImpl::Impl as AstImpl + +/** + * INTERNAL: This module contains the fully generated definition of `SelectionField` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::SelectionField` class directly. + * Use the subclass `SelectionField`, where the following predicates are available. + */ + class SelectionField extends Synth::TSelectionField, AstImpl::Ast { + /** + * Gets the extension name of this selection field, if it exists. + */ + string getExtensionName() { + result = Synth::convertSelectionFieldToRaw(this).(Raw::SelectionField).getExtensionName() + } + + /** + * Holds if `getExtensionName()` exists. + */ + final predicate hasExtensionName() { exists(this.getExtensionName()) } + + /** + * Gets the field of this selection field, if it exists. + */ + string getField() { + result = Synth::convertSelectionFieldToRaw(this).(Raw::SelectionField).getField() + } + + /** + * Holds if `getField()` exists. + */ + final predicate hasField() { exists(this.getField()) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/ShiftLeftExpression.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/ShiftLeftExpression.qll new file mode 100644 index 000000000000..439853734de9 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/ShiftLeftExpression.qll @@ -0,0 +1,25 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `ShiftLeftExpression`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.BinaryExpressionImpl::Impl as BinaryExpressionImpl + +/** + * INTERNAL: This module contains the fully generated definition of `ShiftLeftExpression` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::ShiftLeftExpression` class directly. + * Use the subclass `ShiftLeftExpression`, where the following predicates are available. + */ + class ShiftLeftExpression extends Synth::TShiftLeftExpression, + BinaryExpressionImpl::BinaryExpression + { + override string getAPrimaryQlClass() { result = "ShiftLeftExpression" } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/ShiftRightExpression.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/ShiftRightExpression.qll new file mode 100644 index 000000000000..caa61f14890a --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/ShiftRightExpression.qll @@ -0,0 +1,25 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `ShiftRightExpression`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.BinaryExpressionImpl::Impl as BinaryExpressionImpl + +/** + * INTERNAL: This module contains the fully generated definition of `ShiftRightExpression` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::ShiftRightExpression` class directly. + * Use the subclass `ShiftRightExpression`, where the following predicates are available. + */ + class ShiftRightExpression extends Synth::TShiftRightExpression, + BinaryExpressionImpl::BinaryExpression + { + override string getAPrimaryQlClass() { result = "ShiftRightExpression" } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/SimpleField.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/SimpleField.qll new file mode 100644 index 000000000000..1d31eb8cf645 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/SimpleField.qll @@ -0,0 +1,52 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `SimpleField`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.FieldSpecificationImpl::Impl as FieldSpecificationImpl + +/** + * INTERNAL: This module contains the fully generated definition of `SimpleField` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::SimpleField` class directly. + * Use the subclass `SimpleField`, where the following predicates are available. + */ + class SimpleField extends Synth::TSimpleField, FieldSpecificationImpl::FieldSpecification { + override string getAPrimaryQlClass() { result = "SimpleField" } + + /** + * Gets the extension name of this simple field, if it exists. + */ + string getExtensionName() { + result = Synth::convertSimpleFieldToRaw(this).(Raw::SimpleField).getExtensionName() + } + + /** + * Holds if `getExtensionName()` exists. + */ + final predicate hasExtensionName() { exists(this.getExtensionName()) } + + /** + * Holds if this simple field is name escaped. + */ + predicate isNameEscaped() { + Synth::convertSimpleFieldToRaw(this).(Raw::SimpleField).isNameEscaped() + } + + /** + * Gets the name of this simple field, if it exists. + */ + string getName() { result = Synth::convertSimpleFieldToRaw(this).(Raw::SimpleField).getName() } + + /** + * Holds if `getName()` exists. + */ + final predicate hasName() { exists(this.getName()) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/SimpleInstanceName.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/SimpleInstanceName.qll new file mode 100644 index 000000000000..7c785c410f0a --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/SimpleInstanceName.qll @@ -0,0 +1,51 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `SimpleInstanceName`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.Expression +import codeql.xpp.elements.internal.InstanceNameImpl::Impl as InstanceNameImpl + +/** + * INTERNAL: This module contains the fully generated definition of `SimpleInstanceName` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::SimpleInstanceName` class directly. + * Use the subclass `SimpleInstanceName`, where the following predicates are available. + */ + class SimpleInstanceName extends Synth::TSimpleInstanceName, InstanceNameImpl::InstanceName { + override string getAPrimaryQlClass() { result = "SimpleInstanceName" } + + /** + * Gets the index of this simple instance name, if it exists. + */ + Expression getIndex() { + result = + Synth::convertExpressionFromRaw(Synth::convertSimpleInstanceNameToRaw(this) + .(Raw::SimpleInstanceName) + .getIndex()) + } + + /** + * Holds if `getIndex()` exists. + */ + final predicate hasIndex() { exists(this.getIndex()) } + + /** + * Gets the name of this simple instance name, if it exists. + */ + string getName() { + result = Synth::convertSimpleInstanceNameToRaw(this).(Raw::SimpleInstanceName).getName() + } + + /** + * Holds if `getName()` exists. + */ + final predicate hasName() { exists(this.getName()) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/SimpleOrderElement.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/SimpleOrderElement.qll new file mode 100644 index 000000000000..0cd0044b06c4 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/SimpleOrderElement.qll @@ -0,0 +1,36 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `SimpleOrderElement`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.OrderElementImpl::Impl as OrderElementImpl + +/** + * INTERNAL: This module contains the fully generated definition of `SimpleOrderElement` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::SimpleOrderElement` class directly. + * Use the subclass `SimpleOrderElement`, where the following predicates are available. + */ + class SimpleOrderElement extends Synth::TSimpleOrderElement, OrderElementImpl::OrderElement { + override string getAPrimaryQlClass() { result = "SimpleOrderElement" } + + /** + * Gets the extension name of this simple order element, if it exists. + */ + string getExtensionName() { + result = + Synth::convertSimpleOrderElementToRaw(this).(Raw::SimpleOrderElement).getExtensionName() + } + + /** + * Holds if `getExtensionName()` exists. + */ + final predicate hasExtensionName() { exists(this.getExtensionName()) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/SimpleQualifier.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/SimpleQualifier.qll new file mode 100644 index 000000000000..3f57611d3e39 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/SimpleQualifier.qll @@ -0,0 +1,33 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `SimpleQualifier`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.QualifierImpl::Impl as QualifierImpl + +/** + * INTERNAL: This module contains the fully generated definition of `SimpleQualifier` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::SimpleQualifier` class directly. + * Use the subclass `SimpleQualifier`, where the following predicates are available. + */ + class SimpleQualifier extends Synth::TSimpleQualifier, QualifierImpl::Qualifier { + /** + * Gets the name of this simple qualifier, if it exists. + */ + string getName() { + result = Synth::convertSimpleQualifierToRaw(this).(Raw::SimpleQualifier).getName() + } + + /** + * Holds if `getName()` exists. + */ + final predicate hasName() { exists(this.getName()) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/SimpleQualifierInternal.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/SimpleQualifierInternal.qll new file mode 100644 index 000000000000..181eb5984c62 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/SimpleQualifierInternal.qll @@ -0,0 +1,25 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `SimpleQualifierInternal`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.SimpleQualifierImpl::Impl as SimpleQualifierImpl + +/** + * INTERNAL: This module contains the fully generated definition of `SimpleQualifierInternal` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::SimpleQualifierInternal` class directly. + * Use the subclass `SimpleQualifierInternal`, where the following predicates are available. + */ + class SimpleQualifierInternal extends Synth::TSimpleQualifierInternal, + SimpleQualifierImpl::SimpleQualifier + { + override string getAPrimaryQlClass() { result = "SimpleQualifierInternal" } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/Statement.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/Statement.qll new file mode 100644 index 000000000000..80af60e84739 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/Statement.qll @@ -0,0 +1,33 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `Statement`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.AstImpl::Impl as AstImpl + +/** + * INTERNAL: This module contains the fully generated definition of `Statement` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::Statement` class directly. + * Use the subclass `Statement`, where the following predicates are available. + */ + class Statement extends Synth::TStatement, AstImpl::Ast { + /** + * Gets the comments of this statement, if it exists. + */ + string getComments() { + result = Synth::convertStatementToRaw(this).(Raw::Statement).getComments() + } + + /** + * Holds if `getComments()` exists. + */ + final predicate hasComments() { exists(this.getComments()) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/StaticField.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/StaticField.qll new file mode 100644 index 000000000000..ab84cb483d3c --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/StaticField.qll @@ -0,0 +1,45 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `StaticField`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.FieldSpecificationImpl::Impl as FieldSpecificationImpl + +/** + * INTERNAL: This module contains the fully generated definition of `StaticField` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::StaticField` class directly. + * Use the subclass `StaticField`, where the following predicates are available. + */ + class StaticField extends Synth::TStaticField, FieldSpecificationImpl::FieldSpecification { + override string getAPrimaryQlClass() { result = "StaticField" } + + /** + * Gets the class name of this static field, if it exists. + */ + string getClassName() { + result = Synth::convertStaticFieldToRaw(this).(Raw::StaticField).getClassName() + } + + /** + * Holds if `getClassName()` exists. + */ + final predicate hasClassName() { exists(this.getClassName()) } + + /** + * Gets the name of this static field, if it exists. + */ + string getName() { result = Synth::convertStaticFieldToRaw(this).(Raw::StaticField).getName() } + + /** + * Holds if `getName()` exists. + */ + final predicate hasName() { exists(this.getName()) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/StaticMethodCall.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/StaticMethodCall.qll new file mode 100644 index 000000000000..5c66f7c7e08a --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/StaticMethodCall.qll @@ -0,0 +1,70 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `StaticMethodCall`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.GenericEvaluationImpl::Impl as GenericEvaluationImpl +import codeql.xpp.elements.XppType + +/** + * INTERNAL: This module contains the fully generated definition of `StaticMethodCall` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::StaticMethodCall` class directly. + * Use the subclass `StaticMethodCall`, where the following predicates are available. + */ + class StaticMethodCall extends Synth::TStaticMethodCall, GenericEvaluationImpl::GenericEvaluation { + override string getAPrimaryQlClass() { result = "StaticMethodCall" } + + /** + * Gets the class name of this static method call, if it exists. + */ + string getClassName() { + result = Synth::convertStaticMethodCallToRaw(this).(Raw::StaticMethodCall).getClassName() + } + + /** + * Holds if `getClassName()` exists. + */ + final predicate hasClassName() { exists(this.getClassName()) } + + /** + * Gets the `index`th class type argument list of this static method call (0-based). + */ + XppType getClassTypeArgumentList(int index) { + result = + Synth::convertXppTypeFromRaw(Synth::convertStaticMethodCallToRaw(this) + .(Raw::StaticMethodCall) + .getClassTypeArgumentList(index)) + } + + /** + * Gets any of the class type argument lists of this static method call. + */ + final XppType getAClassTypeArgumentList() { result = this.getClassTypeArgumentList(_) } + + /** + * Gets the number of class type argument lists of this static method call. + */ + final int getNumberOfClassTypeArgumentLists() { + result = count(int i | exists(this.getClassTypeArgumentList(i))) + } + + /** + * Gets the method name of this static method call, if it exists. + */ + string getMethodName() { + result = Synth::convertStaticMethodCallToRaw(this).(Raw::StaticMethodCall).getMethodName() + } + + /** + * Holds if `getMethodName()` exists. + */ + final predicate hasMethodName() { exists(this.getMethodName()) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/StaticQualifier.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/StaticQualifier.qll new file mode 100644 index 000000000000..38f98632a752 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/StaticQualifier.qll @@ -0,0 +1,46 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `StaticQualifier`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.SimpleQualifierImpl::Impl as SimpleQualifierImpl +import codeql.xpp.elements.XppType + +/** + * INTERNAL: This module contains the fully generated definition of `StaticQualifier` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::StaticQualifier` class directly. + * Use the subclass `StaticQualifier`, where the following predicates are available. + */ + class StaticQualifier extends Synth::TStaticQualifier, SimpleQualifierImpl::SimpleQualifier { + override string getAPrimaryQlClass() { result = "StaticQualifier" } + + /** + * Gets the `index`th class type argument list of this static qualifier (0-based). + */ + XppType getClassTypeArgumentList(int index) { + result = + Synth::convertXppTypeFromRaw(Synth::convertStaticQualifierToRaw(this) + .(Raw::StaticQualifier) + .getClassTypeArgumentList(index)) + } + + /** + * Gets any of the class type argument lists of this static qualifier. + */ + final XppType getAClassTypeArgumentList() { result = this.getClassTypeArgumentList(_) } + + /** + * Gets the number of class type argument lists of this static qualifier. + */ + final int getNumberOfClassTypeArgumentLists() { + result = count(int i | exists(this.getClassTypeArgumentList(i))) + } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/StringAttributeLiteral.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/StringAttributeLiteral.qll new file mode 100644 index 000000000000..4444e37809b0 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/StringAttributeLiteral.qll @@ -0,0 +1,25 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `StringAttributeLiteral`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.DefaultTypeAttributeLiteralImpl::Impl as DefaultTypeAttributeLiteralImpl + +/** + * INTERNAL: This module contains the fully generated definition of `StringAttributeLiteral` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::StringAttributeLiteral` class directly. + * Use the subclass `StringAttributeLiteral`, where the following predicates are available. + */ + class StringAttributeLiteral extends Synth::TStringAttributeLiteral, + DefaultTypeAttributeLiteralImpl::DefaultTypeAttributeLiteral + { + override string getAPrimaryQlClass() { result = "StringAttributeLiteral" } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/StringLengthType.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/StringLengthType.qll new file mode 100644 index 000000000000..67f1540a91f7 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/StringLengthType.qll @@ -0,0 +1,52 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `StringLengthType`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.StringTypeImpl::Impl as StringTypeImpl + +/** + * INTERNAL: This module contains the fully generated definition of `StringLengthType` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::StringLengthType` class directly. + * Use the subclass `StringLengthType`, where the following predicates are available. + */ + class StringLengthType extends Synth::TStringLengthType, StringTypeImpl::StringType { + override string getAPrimaryQlClass() { result = "StringLengthType" } + + /** + * Gets the edt name of this string length type, if it exists. + */ + string getEdtName() { + result = Synth::convertStringLengthTypeToRaw(this).(Raw::StringLengthType).getEdtName() + } + + /** + * Holds if `getEdtName()` exists. + */ + final predicate hasEdtName() { exists(this.getEdtName()) } + + /** + * Holds if this string length type is edt. + */ + predicate isEdt() { Synth::convertStringLengthTypeToRaw(this).(Raw::StringLengthType).isEdt() } + + /** + * Gets the length of this string length type, if it exists. + */ + int getLength() { + result = Synth::convertStringLengthTypeToRaw(this).(Raw::StringLengthType).getLength() + } + + /** + * Holds if `getLength()` exists. + */ + final predicate hasLength() { exists(this.getLength()) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/StringLiteralExpression.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/StringLiteralExpression.qll new file mode 100644 index 000000000000..d1f8dfae0425 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/StringLiteralExpression.qll @@ -0,0 +1,60 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `StringLiteralExpression`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.DefaultTypeLiteralExpressionImpl::Impl as DefaultTypeLiteralExpressionImpl + +/** + * INTERNAL: This module contains the fully generated definition of `StringLiteralExpression` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::StringLiteralExpression` class directly. + * Use the subclass `StringLiteralExpression`, where the following predicates are available. + */ + class StringLiteralExpression extends Synth::TStringLiteralExpression, + DefaultTypeLiteralExpressionImpl::DefaultTypeLiteralExpression + { + override string getAPrimaryQlClass() { result = "StringLiteralExpression" } + + /** + * Holds if this string literal expression is label. + */ + predicate isLabel() { + Synth::convertStringLiteralExpressionToRaw(this).(Raw::StringLiteralExpression).isLabel() + } + + /** + * Gets the label file of this string literal expression, if it exists. + */ + string getLabelFileId() { + result = + Synth::convertStringLiteralExpressionToRaw(this) + .(Raw::StringLiteralExpression) + .getLabelFileId() + } + + /** + * Holds if `getLabelFileId()` exists. + */ + final predicate hasLabelFileId() { exists(this.getLabelFileId()) } + + /** + * Gets the label of this string literal expression, if it exists. + */ + string getLabelId() { + result = + Synth::convertStringLiteralExpressionToRaw(this).(Raw::StringLiteralExpression).getLabelId() + } + + /** + * Holds if `getLabelId()` exists. + */ + final predicate hasLabelId() { exists(this.getLabelId()) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/StringType.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/StringType.qll new file mode 100644 index 000000000000..78b1b936f68b --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/StringType.qll @@ -0,0 +1,21 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `StringType`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.XppTypeImpl::Impl as XppTypeImpl + +/** + * INTERNAL: This module contains the fully generated definition of `StringType` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::StringType` class directly. + * Use the subclass `StringType`, where the following predicates are available. + */ + class StringType extends Synth::TStringType, XppTypeImpl::XppType { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/StringTypeInternal.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/StringTypeInternal.qll new file mode 100644 index 000000000000..31e6df8b43c7 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/StringTypeInternal.qll @@ -0,0 +1,23 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `StringTypeInternal`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.StringTypeImpl::Impl as StringTypeImpl + +/** + * INTERNAL: This module contains the fully generated definition of `StringTypeInternal` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::StringTypeInternal` class directly. + * Use the subclass `StringTypeInternal`, where the following predicates are available. + */ + class StringTypeInternal extends Synth::TStringTypeInternal, StringTypeImpl::StringType { + override string getAPrimaryQlClass() { result = "StringTypeInternal" } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/SubtractExpression.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/SubtractExpression.qll new file mode 100644 index 000000000000..977999de34e3 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/SubtractExpression.qll @@ -0,0 +1,25 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `SubtractExpression`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.BinaryExpressionImpl::Impl as BinaryExpressionImpl + +/** + * INTERNAL: This module contains the fully generated definition of `SubtractExpression` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::SubtractExpression` class directly. + * Use the subclass `SubtractExpression`, where the following predicates are available. + */ + class SubtractExpression extends Synth::TSubtractExpression, + BinaryExpressionImpl::BinaryExpression + { + override string getAPrimaryQlClass() { result = "SubtractExpression" } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/SumAggregateSelection.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/SumAggregateSelection.qll new file mode 100644 index 000000000000..d208c2a8f5e8 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/SumAggregateSelection.qll @@ -0,0 +1,25 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `SumAggregateSelection`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.AggregateSelectionImpl::Impl as AggregateSelectionImpl + +/** + * INTERNAL: This module contains the fully generated definition of `SumAggregateSelection` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::SumAggregateSelection` class directly. + * Use the subclass `SumAggregateSelection`, where the following predicates are available. + */ + class SumAggregateSelection extends Synth::TSumAggregateSelection, + AggregateSelectionImpl::AggregateSelection + { + override string getAPrimaryQlClass() { result = "SumAggregateSelection" } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/SuperCall.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/SuperCall.qll new file mode 100644 index 000000000000..8a7e21bce547 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/SuperCall.qll @@ -0,0 +1,23 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `SuperCall`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.EvaluationImpl::Impl as EvaluationImpl + +/** + * INTERNAL: This module contains the fully generated definition of `SuperCall` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::SuperCall` class directly. + * Use the subclass `SuperCall`, where the following predicates are available. + */ + class SuperCall extends Synth::TSuperCall, EvaluationImpl::Evaluation { + override string getAPrimaryQlClass() { result = "SuperCall" } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/SwitchCase.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/SwitchCase.qll new file mode 100644 index 000000000000..b8c39a277b22 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/SwitchCase.qll @@ -0,0 +1,23 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `SwitchCase`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.AstImpl::Impl as AstImpl + +/** + * INTERNAL: This module contains the fully generated definition of `SwitchCase` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::SwitchCase` class directly. + * Use the subclass `SwitchCase`, where the following predicates are available. + */ + class SwitchCase extends Synth::TSwitchCase, AstImpl::Ast { + override string getAPrimaryQlClass() { result = "SwitchCase" } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/SwitchStatement.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/SwitchStatement.qll new file mode 100644 index 000000000000..a903b9a7ff83 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/SwitchStatement.qll @@ -0,0 +1,60 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `SwitchStatement`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.Expression +import codeql.xpp.elements.internal.StatementImpl::Impl as StatementImpl +import codeql.xpp.elements.SwitchStatementCaseEntry + +/** + * INTERNAL: This module contains the fully generated definition of `SwitchStatement` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::SwitchStatement` class directly. + * Use the subclass `SwitchStatement`, where the following predicates are available. + */ + class SwitchStatement extends Synth::TSwitchStatement, StatementImpl::Statement { + override string getAPrimaryQlClass() { result = "SwitchStatement" } + + /** + * Gets the `index`th case of this switch statement (0-based). + */ + SwitchStatementCaseEntry getCase(int index) { + result = + Synth::convertSwitchStatementCaseEntryFromRaw(Synth::convertSwitchStatementToRaw(this) + .(Raw::SwitchStatement) + .getCase(index)) + } + + /** + * Gets any of the cases of this switch statement. + */ + final SwitchStatementCaseEntry getACase() { result = this.getCase(_) } + + /** + * Gets the number of cases of this switch statement. + */ + final int getNumberOfCases() { result = count(int i | exists(this.getCase(i))) } + + /** + * Gets the selector of this switch statement, if it exists. + */ + Expression getSelector() { + result = + Synth::convertExpressionFromRaw(Synth::convertSwitchStatementToRaw(this) + .(Raw::SwitchStatement) + .getSelector()) + } + + /** + * Holds if `getSelector()` exists. + */ + final predicate hasSelector() { exists(this.getSelector()) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/SwitchStatementCaseEntry.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/SwitchStatementCaseEntry.qll new file mode 100644 index 000000000000..c5d26769c4c2 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/SwitchStatementCaseEntry.qll @@ -0,0 +1,60 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `SwitchStatementCaseEntry`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.Case +import codeql.xpp.elements.Statement +import codeql.xpp.elements.internal.XppTupleImpl::Impl as XppTupleImpl + +/** + * INTERNAL: This module contains the fully generated definition of `SwitchStatementCaseEntry` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::SwitchStatementCaseEntry` class directly. + * Use the subclass `SwitchStatementCaseEntry`, where the following predicates are available. + */ + class SwitchStatementCaseEntry extends Synth::TSwitchStatementCaseEntry, XppTupleImpl::XppTuple { + override string getAPrimaryQlClass() { result = "SwitchStatementCaseEntry" } + + /** + * Gets the case of this switch statement case entry, if it exists. + */ + Case getCase() { + result = + Synth::convertCaseFromRaw(Synth::convertSwitchStatementCaseEntryToRaw(this) + .(Raw::SwitchStatementCaseEntry) + .getCase()) + } + + /** + * Holds if `getCase()` exists. + */ + final predicate hasCase() { exists(this.getCase()) } + + /** + * Gets the `index`th statement of this switch statement case entry (0-based). + */ + Statement getStatement(int index) { + result = + Synth::convertStatementFromRaw(Synth::convertSwitchStatementCaseEntryToRaw(this) + .(Raw::SwitchStatementCaseEntry) + .getStatement(index)) + } + + /** + * Gets any of the statements of this switch statement case entry. + */ + final Statement getAStatement() { result = this.getStatement(_) } + + /** + * Gets the number of statements of this switch statement case entry. + */ + final int getNumberOfStatements() { result = count(int i | exists(this.getStatement(i))) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/Synth.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/Synth.qll new file mode 100644 index 000000000000..6afdc01bbb84 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/Synth.qll @@ -0,0 +1,6191 @@ +/** + * INTERNAL: Do not use. + * This module defines the IPA layer on top of raw DB entities, and the conversions between the two + * layers. + */ + +private import codeql.xpp.elements.internal.generated.SynthConstructors +private import codeql.xpp.elements.internal.generated.Raw + +module Synth { + /** + * INTERNAL: Do not use. + * The synthesized type of all elements. + */ + cached + newtype TElement = + /** + * INTERNAL: Do not use. + */ + TAddExpression(Raw::AddExpression id) { constructAddExpression(id) } or + /** + * INTERNAL: Do not use. + */ + TAllFieldsSelection(Raw::AllFieldsSelection id) { constructAllFieldsSelection(id) } or + /** + * INTERNAL: Do not use. + */ + TAndExpression(Raw::AndExpression id) { constructAndExpression(id) } or + /** + * INTERNAL: Do not use. + */ + TAnyType(Raw::AnyType id) { constructAnyType(id) } or + /** + * INTERNAL: Do not use. + */ + TArraySpecification(Raw::ArraySpecification id) { constructArraySpecification(id) } or + /** + * INTERNAL: Do not use. + */ + TAsClrExpression(Raw::AsClrExpression id) { constructAsClrExpression(id) } or + /** + * INTERNAL: Do not use. + */ + TAsExpression(Raw::AsExpression id) { constructAsExpression(id) } or + /** + * INTERNAL: Do not use. + */ + TAssignDecrementStatement(Raw::AssignDecrementStatement id) { + constructAssignDecrementStatement(id) + } or + /** + * INTERNAL: Do not use. + */ + TAssignDivideStatement(Raw::AssignDivideStatement id) { constructAssignDivideStatement(id) } or + /** + * INTERNAL: Do not use. + */ + TAssignEqualStatement(Raw::AssignEqualStatement id) { constructAssignEqualStatement(id) } or + /** + * INTERNAL: Do not use. + */ + TAssignIncrementStatement(Raw::AssignIncrementStatement id) { + constructAssignIncrementStatement(id) + } or + /** + * INTERNAL: Do not use. + */ + TAssignMultipleFieldStatement(Raw::AssignMultipleFieldStatement id) { + constructAssignMultipleFieldStatement(id) + } or + /** + * INTERNAL: Do not use. + */ + TAssignMultiplyStatement(Raw::AssignMultiplyStatement id) { + constructAssignMultiplyStatement(id) + } or + /** + * INTERNAL: Do not use. + */ + TAssignPostDecrementStatement(Raw::AssignPostDecrementStatement id) { + constructAssignPostDecrementStatement(id) + } or + /** + * INTERNAL: Do not use. + */ + TAssignPostIncrementStatement(Raw::AssignPostIncrementStatement id) { + constructAssignPostIncrementStatement(id) + } or + /** + * INTERNAL: Do not use. + */ + TAssignPreDecrementStatement(Raw::AssignPreDecrementStatement id) { + constructAssignPreDecrementStatement(id) + } or + /** + * INTERNAL: Do not use. + */ + TAssignPreIncrementStatement(Raw::AssignPreIncrementStatement id) { + constructAssignPreIncrementStatement(id) + } or + /** + * INTERNAL: Do not use. + */ + TAssignmentEventHandlerClr(Raw::AssignmentEventHandlerClr id) { + constructAssignmentEventHandlerClr(id) + } or + /** + * INTERNAL: Do not use. + */ + TAssignmentEventHandlerInstance(Raw::AssignmentEventHandlerInstance id) { + constructAssignmentEventHandlerInstance(id) + } or + /** + * INTERNAL: Do not use. + */ + TAssignmentEventHandlerStaticInternal(Raw::AssignmentEventHandlerStaticInternal id) { + constructAssignmentEventHandlerStaticInternal(id) + } or + /** + * INTERNAL: Do not use. + */ + TAttribute(Raw::Attribute id) { constructAttribute(id) } or + /** + * INTERNAL: Do not use. + */ + TAttributeExpression(Raw::AttributeExpression id) { constructAttributeExpression(id) } or + /** + * INTERNAL: Do not use. + */ + TAttributeList(Raw::AttributeList id) { constructAttributeList(id) } or + /** + * INTERNAL: Do not use. + */ + TAttributeNamedParameterEntry(Raw::AttributeNamedParameterEntry id) { + constructAttributeNamedParameterEntry(id) + } or + /** + * INTERNAL: Do not use. + */ + TAvgAggregateSelection(Raw::AvgAggregateSelection id) { constructAvgAggregateSelection(id) } or + /** + * INTERNAL: Do not use. + */ + TBooleanAttributeLiteral(Raw::BooleanAttributeLiteral id) { + constructBooleanAttributeLiteral(id) + } or + /** + * INTERNAL: Do not use. + */ + TBooleanLiteralExpression(Raw::BooleanLiteralExpression id) { + constructBooleanLiteralExpression(id) + } or + /** + * INTERNAL: Do not use. + */ + TBooleanType(Raw::BooleanType id) { constructBooleanType(id) } or + /** + * INTERNAL: Do not use. + */ + TBreakStatement(Raw::BreakStatement id) { constructBreakStatement(id) } or + /** + * INTERNAL: Do not use. + */ + TBreakpointStatement(Raw::BreakpointStatement id) { constructBreakpointStatement(id) } or + /** + * INTERNAL: Do not use. + */ + TCaseDefault(Raw::CaseDefault id) { constructCaseDefault(id) } or + /** + * INTERNAL: Do not use. + */ + TCaseValues(Raw::CaseValues id) { constructCaseValues(id) } or + /** + * INTERNAL: Do not use. + */ + TCatchAllValues(Raw::CatchAllValues id) { constructCatchAllValues(id) } or + /** + * INTERNAL: Do not use. + */ + TCatchExpression(Raw::CatchExpression id) { constructCatchExpression(id) } or + /** + * INTERNAL: Do not use. + */ + TCatchUpdateConflict(Raw::CatchUpdateConflict id) { constructCatchUpdateConflict(id) } or + /** + * INTERNAL: Do not use. + */ + TChangeCompanyStatement(Raw::ChangeCompanyStatement id) { constructChangeCompanyStatement(id) } or + /** + * INTERNAL: Do not use. + */ + TClass(Raw::Class id) { constructClass(id) } or + /** + * INTERNAL: Do not use. + */ + TClassAccessModifier(Raw::ClassAccessModifier id) { constructClassAccessModifier(id) } or + /** + * INTERNAL: Do not use. + */ + TClrEnumerationLiteralExpression(Raw::ClrEnumerationLiteralExpression id) { + constructClrEnumerationLiteralExpression(id) + } or + /** + * INTERNAL: Do not use. + */ + TClrType(Raw::ClrType id) { constructClrType(id) } or + /** + * INTERNAL: Do not use. + */ + TComment(Raw::Comment id) { constructComment(id) } or + /** + * INTERNAL: Do not use. + */ + TCompilationUnitRegionEntry(Raw::CompilationUnitRegionEntry id) { + constructCompilationUnitRegionEntry(id) + } or + /** + * INTERNAL: Do not use. + */ + TCompoundStatement(Raw::CompoundStatement id) { constructCompoundStatement(id) } or + /** + * INTERNAL: Do not use. + */ + TConditionalExpression(Raw::ConditionalExpression id) { constructConditionalExpression(id) } or + /** + * INTERNAL: Do not use. + */ + TContainerAttributeLiteral(Raw::ContainerAttributeLiteral id) { + constructContainerAttributeLiteral(id) + } or + /** + * INTERNAL: Do not use. + */ + TContainerLiteralExpression(Raw::ContainerLiteralExpression id) { + constructContainerLiteralExpression(id) + } or + /** + * INTERNAL: Do not use. + */ + TContainerType(Raw::ContainerType id) { constructContainerType(id) } or + /** + * INTERNAL: Do not use. + */ + TContinueStatement(Raw::ContinueStatement id) { constructContinueStatement(id) } or + /** + * INTERNAL: Do not use. + */ + TCountAggregateSelection(Raw::CountAggregateSelection id) { + constructCountAggregateSelection(id) + } or + /** + * INTERNAL: Do not use. + */ + TCrossCompanyAll(Raw::CrossCompanyAll id) { constructCrossCompanyAll(id) } or + /** + * INTERNAL: Do not use. + */ + TCrossCompanyContainer(Raw::CrossCompanyContainer id) { constructCrossCompanyContainer(id) } or + /** + * INTERNAL: Do not use. + */ + TDateAttributeLiteral(Raw::DateAttributeLiteral id) { constructDateAttributeLiteral(id) } or + /** + * INTERNAL: Do not use. + */ + TDateLiteralExpression(Raw::DateLiteralExpression id) { constructDateLiteralExpression(id) } or + /** + * INTERNAL: Do not use. + */ + TDateTimeAttributeLiteral(Raw::DateTimeAttributeLiteral id) { + constructDateTimeAttributeLiteral(id) + } or + /** + * INTERNAL: Do not use. + */ + TDateTimeLiteralExpression(Raw::DateTimeLiteralExpression id) { + constructDateTimeLiteralExpression(id) + } or + /** + * INTERNAL: Do not use. + */ + TDateTimeType(Raw::DateTimeType id) { constructDateTimeType(id) } or + /** + * INTERNAL: Do not use. + */ + TDateType(Raw::DateType id) { constructDateType(id) } or + /** + * INTERNAL: Do not use. + */ + TDblAttributeLiteral(Raw::DblAttributeLiteral id) { constructDblAttributeLiteral(id) } or + /** + * INTERNAL: Do not use. + */ + TDblType(Raw::DblType id) { constructDblType(id) } or + /** + * INTERNAL: Do not use. + */ + TDelegate(Raw::Delegate id) { constructDelegate(id) } or + /** + * INTERNAL: Do not use. + */ + TDeleteStatement(Raw::DeleteStatement id) { constructDeleteStatement(id) } or + /** + * INTERNAL: Do not use. + */ + TDivideExpression(Raw::DivideExpression id) { constructDivideExpression(id) } or + /** + * INTERNAL: Do not use. + */ + TDoWhileStatement(Raw::DoWhileStatement id) { constructDoWhileStatement(id) } or + /** + * INTERNAL: Do not use. + */ + TEmptyExpression(Raw::EmptyExpression id) { constructEmptyExpression(id) } or + /** + * INTERNAL: Do not use. + */ + TEmptyStatement(Raw::EmptyStatement id) { constructEmptyStatement(id) } or + /** + * INTERNAL: Do not use. + */ + TEnumAttributeLiteral(Raw::EnumAttributeLiteral id) { constructEnumAttributeLiteral(id) } or + /** + * INTERNAL: Do not use. + */ + TEnumerationLiteralExpression(Raw::EnumerationLiteralExpression id) { + constructEnumerationLiteralExpression(id) + } or + /** + * INTERNAL: Do not use. + */ + TEnumerationType(Raw::EnumerationType id) { constructEnumerationType(id) } or + /** + * INTERNAL: Do not use. + */ + TEqualExpression(Raw::EqualExpression id) { constructEqualExpression(id) } or + /** + * INTERNAL: Do not use. + */ + TEvaluationActualParameterEntry(Raw::EvaluationActualParameterEntry id) { + constructEvaluationActualParameterEntry(id) + } or + /** + * INTERNAL: Do not use. + */ + TExplicitSelection(Raw::ExplicitSelection id) { constructExplicitSelection(id) } or + /** + * INTERNAL: Do not use. + */ + TExpressionCompilationUnit(Raw::ExpressionCompilationUnit id) { + constructExpressionCompilationUnit(id) + } or + /** + * INTERNAL: Do not use. + */ + TExpressionQualifier(Raw::ExpressionQualifier id) { constructExpressionQualifier(id) } or + /** + * INTERNAL: Do not use. + */ + TExpressionStatement(Raw::ExpressionStatement id) { constructExpressionStatement(id) } or + /** + * INTERNAL: Do not use. + */ + TFieldAssignment(Raw::FieldAssignment id) { constructFieldAssignment(id) } or + /** + * INTERNAL: Do not use. + */ + TFieldDeclarationInternal(Raw::FieldDeclarationInternal id) { + constructFieldDeclarationInternal(id) + } or + /** + * INTERNAL: Do not use. + */ + TFieldExpressionInternal(Raw::FieldExpressionInternal id) { + constructFieldExpressionInternal(id) + } or + /** + * INTERNAL: Do not use. + */ + TFieldSelection(Raw::FieldSelection id) { constructFieldSelection(id) } or + /** + * INTERNAL: Do not use. + */ + TFile(Raw::File id) { constructFile(id) } or + /** + * INTERNAL: Do not use. + */ + TFindStatement(Raw::FindStatement id) { constructFindStatement(id) } or + /** + * INTERNAL: Do not use. + */ + TFlushStatement(Raw::FlushStatement id) { constructFlushStatement(id) } or + /** + * INTERNAL: Do not use. + */ + TForDeclarationAssign(Raw::ForDeclarationAssign id) { constructForDeclarationAssign(id) } or + /** + * INTERNAL: Do not use. + */ + TForFieldAssign(Raw::ForFieldAssign id) { constructForFieldAssign(id) } or + /** + * INTERNAL: Do not use. + */ + TForFieldDecrementAssign(Raw::ForFieldDecrementAssign id) { + constructForFieldDecrementAssign(id) + } or + /** + * INTERNAL: Do not use. + */ + TForFieldIncrementAssign(Raw::ForFieldIncrementAssign id) { + constructForFieldIncrementAssign(id) + } or + /** + * INTERNAL: Do not use. + */ + TForFieldPostDecrement(Raw::ForFieldPostDecrement id) { constructForFieldPostDecrement(id) } or + /** + * INTERNAL: Do not use. + */ + TForFieldPostIncrement(Raw::ForFieldPostIncrement id) { constructForFieldPostIncrement(id) } or + /** + * INTERNAL: Do not use. + */ + TForFieldPreDecrement(Raw::ForFieldPreDecrement id) { constructForFieldPreDecrement(id) } or + /** + * INTERNAL: Do not use. + */ + TForFieldPreIncrement(Raw::ForFieldPreIncrement id) { constructForFieldPreIncrement(id) } or + /** + * INTERNAL: Do not use. + */ + TForStatement(Raw::ForStatement id) { constructForStatement(id) } or + /** + * INTERNAL: Do not use. + */ + TFormControl(Raw::FormControl id) { constructFormControl(id) } or + /** + * INTERNAL: Do not use. + */ + TFormDataField(Raw::FormDataField id) { constructFormDataField(id) } or + /** + * INTERNAL: Do not use. + */ + TFormDataSource(Raw::FormDataSource id) { constructFormDataSource(id) } or + /** + * INTERNAL: Do not use. + */ + TFormElementType(Raw::FormElementType id) { constructFormElementType(id) } or + /** + * INTERNAL: Do not use. + */ + TFormModelElement(Raw::FormModelElement id) { constructFormModelElement(id) } or + /** + * INTERNAL: Do not use. + */ + TFunctionCall(Raw::FunctionCall id) { constructFunctionCall(id) } or + /** + * INTERNAL: Do not use. + */ + TFunctionDeclaration(Raw::FunctionDeclaration id) { constructFunctionDeclaration(id) } or + /** + * INTERNAL: Do not use. + */ + TGlobalOrderElement(Raw::GlobalOrderElement id) { constructGlobalOrderElement(id) } or + /** + * INTERNAL: Do not use. + */ + TGreaterThanExpression(Raw::GreaterThanExpression id) { constructGreaterThanExpression(id) } or + /** + * INTERNAL: Do not use. + */ + TGreaterThanOrEqualExpression(Raw::GreaterThanOrEqualExpression id) { + constructGreaterThanOrEqualExpression(id) + } or + /** + * INTERNAL: Do not use. + */ + TGuidAttributeLiteral(Raw::GuidAttributeLiteral id) { constructGuidAttributeLiteral(id) } or + /** + * INTERNAL: Do not use. + */ + TGuidType(Raw::GuidType id) { constructGuidType(id) } or + /** + * INTERNAL: Do not use. + */ + TIfStatement(Raw::IfStatement id) { constructIfStatement(id) } or + /** + * INTERNAL: Do not use. + */ + TIfThenElseStatement(Raw::IfThenElseStatement id) { constructIfThenElseStatement(id) } or + /** + * INTERNAL: Do not use. + */ + TImplicitSelection(Raw::ImplicitSelection id) { constructImplicitSelection(id) } or + /** + * INTERNAL: Do not use. + */ + TInExpression(Raw::InExpression id) { constructInExpression(id) } or + /** + * INTERNAL: Do not use. + */ + TInsertFieldSpecification(Raw::InsertFieldSpecification id) { + constructInsertFieldSpecification(id) + } or + /** + * INTERNAL: Do not use. + */ + TInsertStatement(Raw::InsertStatement id) { constructInsertStatement(id) } or + /** + * INTERNAL: Do not use. + */ + TInt64AttributeLiteral(Raw::Int64AttributeLiteral id) { constructInt64AttributeLiteral(id) } or + /** + * INTERNAL: Do not use. + */ + TInt64LiteralExpression(Raw::Int64LiteralExpression id) { constructInt64LiteralExpression(id) } or + /** + * INTERNAL: Do not use. + */ + TInt64Type(Raw::Int64Type id) { constructInt64Type(id) } or + /** + * INTERNAL: Do not use. + */ + TIntAttributeLiteral(Raw::IntAttributeLiteral id) { constructIntAttributeLiteral(id) } or + /** + * INTERNAL: Do not use. + */ + TIntLiteralExpression(Raw::IntLiteralExpression id) { constructIntLiteralExpression(id) } or + /** + * INTERNAL: Do not use. + */ + TIntType(Raw::IntType id) { constructIntType(id) } or + /** + * INTERNAL: Do not use. + */ + TIntegerDivideExpression(Raw::IntegerDivideExpression id) { + constructIntegerDivideExpression(id) + } or + /** + * INTERNAL: Do not use. + */ + TInterface(Raw::Interface id) { constructInterface(id) } or + /** + * INTERNAL: Do not use. + */ + TIntrinsic(Raw::Intrinsic id) { constructIntrinsic(id) } or + /** + * INTERNAL: Do not use. + */ + TIntrinsicAttributeLiteral(Raw::IntrinsicAttributeLiteral id) { + constructIntrinsicAttributeLiteral(id) + } or + /** + * INTERNAL: Do not use. + */ + TIsClrExpression(Raw::IsClrExpression id) { constructIsClrExpression(id) } or + /** + * INTERNAL: Do not use. + */ + TIsExpression(Raw::IsExpression id) { constructIsExpression(id) } or + /** + * INTERNAL: Do not use. + */ + TJoinSpecification(Raw::JoinSpecification id) { constructJoinSpecification(id) } or + /** + * INTERNAL: Do not use. + */ + TLessThanExpression(Raw::LessThanExpression id) { constructLessThanExpression(id) } or + /** + * INTERNAL: Do not use. + */ + TLessThanOrEqualExpression(Raw::LessThanOrEqualExpression id) { + constructLessThanOrEqualExpression(id) + } or + /** + * INTERNAL: Do not use. + */ + TLikeExpression(Raw::LikeExpression id) { constructLikeExpression(id) } or + /** + * INTERNAL: Do not use. + */ + TLocalDeclarationsStatement(Raw::LocalDeclarationsStatement id) { + constructLocalDeclarationsStatement(id) + } or + /** + * INTERNAL: Do not use. + */ + TLocation(Raw::Location id) { constructLocation(id) } or + /** + * INTERNAL: Do not use. + */ + TMaxAggregateSelection(Raw::MaxAggregateSelection id) { constructMaxAggregateSelection(id) } or + /** + * INTERNAL: Do not use. + */ + TMethod(Raw::Method id) { constructMethod(id) } or + /** + * INTERNAL: Do not use. + */ + TMinAggregateSelection(Raw::MinAggregateSelection id) { constructMinAggregateSelection(id) } or + /** + * INTERNAL: Do not use. + */ + TModExpression(Raw::ModExpression id) { constructModExpression(id) } or + /** + * INTERNAL: Do not use. + */ + TModelElementUsingEntry(Raw::ModelElementUsingEntry id) { constructModelElementUsingEntry(id) } or + /** + * INTERNAL: Do not use. + */ + TModifier(Raw::Modifier id) { constructModifier(id) } or + /** + * INTERNAL: Do not use. + */ + TMoveCursorStatement(Raw::MoveCursorStatement id) { constructMoveCursorStatement(id) } or + /** + * INTERNAL: Do not use. + */ + TMultiplyExpression(Raw::MultiplyExpression id) { constructMultiplyExpression(id) } or + /** + * INTERNAL: Do not use. + */ + TNamedFieldReference(Raw::NamedFieldReference id) { constructNamedFieldReference(id) } or + /** + * INTERNAL: Do not use. + */ + TNamedTypeInternal(Raw::NamedTypeInternal id) { constructNamedTypeInternal(id) } or + /** + * INTERNAL: Do not use. + */ + TNewCall(Raw::NewCall id) { constructNewCall(id) } or + /** + * INTERNAL: Do not use. + */ + TNewClrArrayExpression(Raw::NewClrArrayExpression id) { constructNewClrArrayExpression(id) } or + /** + * INTERNAL: Do not use. + */ + TNewClrCall(Raw::NewClrCall id) { constructNewClrCall(id) } or + /** + * INTERNAL: Do not use. + */ + TNextExpression(Raw::NextExpression id) { constructNextExpression(id) } or + /** + * INTERNAL: Do not use. + */ + TNotEqualExpression(Raw::NotEqualExpression id) { constructNotEqualExpression(id) } or + /** + * INTERNAL: Do not use. + */ + TNotExpression(Raw::NotExpression id) { constructNotExpression(id) } or + /** + * INTERNAL: Do not use. + */ + TNullLiteralExpression(Raw::NullLiteralExpression id) { constructNullLiteralExpression(id) } or + /** + * INTERNAL: Do not use. + */ + TNumberedFieldReference(Raw::NumberedFieldReference id) { constructNumberedFieldReference(id) } or + /** + * INTERNAL: Do not use. + */ + TOrExpression(Raw::OrExpression id) { constructOrExpression(id) } or + /** + * INTERNAL: Do not use. + */ + TParameterDeclaration(Raw::ParameterDeclaration id) { constructParameterDeclaration(id) } or + /** + * INTERNAL: Do not use. + */ + TPhysicalAndExpression(Raw::PhysicalAndExpression id) { constructPhysicalAndExpression(id) } or + /** + * INTERNAL: Do not use. + */ + TPhysicalNotExpression(Raw::PhysicalNotExpression id) { constructPhysicalNotExpression(id) } or + /** + * INTERNAL: Do not use. + */ + TPhysicalOrExpression(Raw::PhysicalOrExpression id) { constructPhysicalOrExpression(id) } or + /** + * INTERNAL: Do not use. + */ + TPhysicalXorExpression(Raw::PhysicalXorExpression id) { constructPhysicalXorExpression(id) } or + /** + * INTERNAL: Do not use. + */ + TPlaceholder(Raw::Placeholder id) { constructPlaceholder(id) } or + /** + * INTERNAL: Do not use. + */ + TPrintStatement(Raw::PrintStatement id) { constructPrintStatement(id) } or + /** + * INTERNAL: Do not use. + */ + TProvidedType(Raw::ProvidedType id) { constructProvidedType(id) } or + /** + * INTERNAL: Do not use. + */ + TProvidedTypeStaticCall(Raw::ProvidedTypeStaticCall id) { constructProvidedTypeStaticCall(id) } or + /** + * INTERNAL: Do not use. + */ + TQualifiedCall(Raw::QualifiedCall id) { constructQualifiedCall(id) } or + /** + * INTERNAL: Do not use. + */ + TQualifiedField(Raw::QualifiedField id) { constructQualifiedField(id) } or + /** + * INTERNAL: Do not use. + */ + TQualifiedInstanceName(Raw::QualifiedInstanceName id) { constructQualifiedInstanceName(id) } or + /** + * INTERNAL: Do not use. + */ + TQualifiedNumberedField(Raw::QualifiedNumberedField id) { constructQualifiedNumberedField(id) } or + /** + * INTERNAL: Do not use. + */ + TQualifiedStaticCall(Raw::QualifiedStaticCall id) { constructQualifiedStaticCall(id) } or + /** + * INTERNAL: Do not use. + */ + TQualifiedStaticField(Raw::QualifiedStaticField id) { constructQualifiedStaticField(id) } or + /** + * INTERNAL: Do not use. + */ + TQualifiedStaticFieldExpression(Raw::QualifiedStaticFieldExpression id) { + constructQualifiedStaticFieldExpression(id) + } or + /** + * INTERNAL: Do not use. + */ + TQuery(Raw::Query id) { constructQuery(id) } or + /** + * INTERNAL: Do not use. + */ + TQueryDataSource(Raw::QueryDataSource id) { constructQueryDataSource(id) } or + /** + * INTERNAL: Do not use. + */ + TQueryDataSourceHaving(Raw::QueryDataSourceHaving id) { constructQueryDataSourceHaving(id) } or + /** + * INTERNAL: Do not use. + */ + TQueryDataSourceRange(Raw::QueryDataSourceRange id) { constructQueryDataSourceRange(id) } or + /** + * INTERNAL: Do not use. + */ + TQueryDataSourceRelation(Raw::QueryDataSourceRelation id) { + constructQueryDataSourceRelation(id) + } or + /** + * INTERNAL: Do not use. + */ + TQueryModelElement(Raw::QueryModelElement id) { constructQueryModelElement(id) } or + /** + * INTERNAL: Do not use. + */ + TRealLiteralExpression(Raw::RealLiteralExpression id) { constructRealLiteralExpression(id) } or + /** + * INTERNAL: Do not use. + */ + TRetryStatement(Raw::RetryStatement id) { constructRetryStatement(id) } or + /** + * INTERNAL: Do not use. + */ + TReturnStatement(Raw::ReturnStatement id) { constructReturnStatement(id) } or + /** + * INTERNAL: Do not use. + */ + TSearchStatement(Raw::SearchStatement id) { constructSearchStatement(id) } or + /** + * INTERNAL: Do not use. + */ + TShiftLeftExpression(Raw::ShiftLeftExpression id) { constructShiftLeftExpression(id) } or + /** + * INTERNAL: Do not use. + */ + TShiftRightExpression(Raw::ShiftRightExpression id) { constructShiftRightExpression(id) } or + /** + * INTERNAL: Do not use. + */ + TSimpleField(Raw::SimpleField id) { constructSimpleField(id) } or + /** + * INTERNAL: Do not use. + */ + TSimpleInstanceName(Raw::SimpleInstanceName id) { constructSimpleInstanceName(id) } or + /** + * INTERNAL: Do not use. + */ + TSimpleOrderElement(Raw::SimpleOrderElement id) { constructSimpleOrderElement(id) } or + /** + * INTERNAL: Do not use. + */ + TSimpleQualifierInternal(Raw::SimpleQualifierInternal id) { + constructSimpleQualifierInternal(id) + } or + /** + * INTERNAL: Do not use. + */ + TStaticField(Raw::StaticField id) { constructStaticField(id) } or + /** + * INTERNAL: Do not use. + */ + TStaticMethodCall(Raw::StaticMethodCall id) { constructStaticMethodCall(id) } or + /** + * INTERNAL: Do not use. + */ + TStaticQualifier(Raw::StaticQualifier id) { constructStaticQualifier(id) } or + /** + * INTERNAL: Do not use. + */ + TStringAttributeLiteral(Raw::StringAttributeLiteral id) { constructStringAttributeLiteral(id) } or + /** + * INTERNAL: Do not use. + */ + TStringLengthType(Raw::StringLengthType id) { constructStringLengthType(id) } or + /** + * INTERNAL: Do not use. + */ + TStringLiteralExpression(Raw::StringLiteralExpression id) { + constructStringLiteralExpression(id) + } or + /** + * INTERNAL: Do not use. + */ + TStringTypeInternal(Raw::StringTypeInternal id) { constructStringTypeInternal(id) } or + /** + * INTERNAL: Do not use. + */ + TSubtractExpression(Raw::SubtractExpression id) { constructSubtractExpression(id) } or + /** + * INTERNAL: Do not use. + */ + TSumAggregateSelection(Raw::SumAggregateSelection id) { constructSumAggregateSelection(id) } or + /** + * INTERNAL: Do not use. + */ + TSuperCall(Raw::SuperCall id) { constructSuperCall(id) } or + /** + * INTERNAL: Do not use. + */ + TSwitchCase(Raw::SwitchCase id) { constructSwitchCase(id) } or + /** + * INTERNAL: Do not use. + */ + TSwitchStatement(Raw::SwitchStatement id) { constructSwitchStatement(id) } or + /** + * INTERNAL: Do not use. + */ + TSwitchStatementCaseEntry(Raw::SwitchStatementCaseEntry id) { + constructSwitchStatementCaseEntry(id) + } or + /** + * INTERNAL: Do not use. + */ + TTable(Raw::Table id) { constructTable(id) } or + /** + * INTERNAL: Do not use. + */ + TTableFieldDeclaration(Raw::TableFieldDeclaration id) { constructTableFieldDeclaration(id) } or + /** + * INTERNAL: Do not use. + */ + TTableLookupExpression(Raw::TableLookupExpression id) { constructTableLookupExpression(id) } or + /** + * INTERNAL: Do not use. + */ + TThrowStatement(Raw::ThrowStatement id) { constructThrowStatement(id) } or + /** + * INTERNAL: Do not use. + */ + TTryStatement(Raw::TryStatement id) { constructTryStatement(id) } or + /** + * INTERNAL: Do not use. + */ + TTryStatementCatchEntry(Raw::TryStatementCatchEntry id) { constructTryStatementCatchEntry(id) } or + /** + * INTERNAL: Do not use. + */ + TTtsAbortStatement(Raw::TtsAbortStatement id) { constructTtsAbortStatement(id) } or + /** + * INTERNAL: Do not use. + */ + TTtsBeginStatement(Raw::TtsBeginStatement id) { constructTtsBeginStatement(id) } or + /** + * INTERNAL: Do not use. + */ + TTtsEndStatement(Raw::TtsEndStatement id) { constructTtsEndStatement(id) } or + /** + * INTERNAL: Do not use. + */ + TUnaryMinusExpression(Raw::UnaryMinusExpression id) { constructUnaryMinusExpression(id) } or + /** + * INTERNAL: Do not use. + */ + TUncheckedStatement(Raw::UncheckedStatement id) { constructUncheckedStatement(id) } or + /** + * INTERNAL: Do not use. + */ + TUnspecifiedElement(Raw::UnspecifiedElement id) { constructUnspecifiedElement(id) } or + /** + * INTERNAL: Do not use. + */ + TUpdateStatement(Raw::UpdateStatement id) { constructUpdateStatement(id) } or + /** + * INTERNAL: Do not use. + */ + TUsingStatement(Raw::UsingStatement id) { constructUsingStatement(id) } or + /** + * INTERNAL: Do not use. + */ + TValidTimeStateDate(Raw::ValidTimeStateDate id) { constructValidTimeStateDate(id) } or + /** + * INTERNAL: Do not use. + */ + TValidTimeStateRange(Raw::ValidTimeStateRange id) { constructValidTimeStateRange(id) } or + /** + * INTERNAL: Do not use. + */ + TVarType(Raw::VarType id) { constructVarType(id) } or + /** + * INTERNAL: Do not use. + */ + TVariableDeclarationInternal(Raw::VariableDeclarationInternal id) { + constructVariableDeclarationInternal(id) + } or + /** + * INTERNAL: Do not use. + */ + TVoidType(Raw::VoidType id) { constructVoidType(id) } or + /** + * INTERNAL: Do not use. + */ + TWhileStatement(Raw::WhileStatement id) { constructWhileStatement(id) } or + /** + * INTERNAL: Do not use. + */ + TXppTypeCompilationUnit(Raw::XppTypeCompilationUnit id) { constructXppTypeCompilationUnit(id) } + + /** + * INTERNAL: Do not use. + */ + class TAggregateSelection = + TAvgAggregateSelection or TCountAggregateSelection or TMaxAggregateSelection or + TMinAggregateSelection or TSumAggregateSelection; + + /** + * INTERNAL: Do not use. + */ + class TAssignmentBinary = + TAssignDecrementStatement or TAssignDivideStatement or TAssignEqualStatement or + TAssignIncrementStatement or TAssignMultiplyStatement; + + /** + * INTERNAL: Do not use. + */ + class TAssignmentEventHandlerBase = + TAssignmentEventHandlerInstance or TAssignmentEventHandlerStatic; + + /** + * INTERNAL: Do not use. + */ + class TAssignmentEventHandlerStatic = + TAssignmentEventHandlerClr or TAssignmentEventHandlerStaticInternal; + + /** + * INTERNAL: Do not use. + */ + class TAssignmentSingleField = + TAssignPostDecrementStatement or TAssignPostIncrementStatement or + TAssignPreDecrementStatement or TAssignPreIncrementStatement or TAssignmentBinary or + TAssignmentEventHandlerBase; + + /** + * INTERNAL: Do not use. + */ + class TAssignmentStatement = TAssignMultipleFieldStatement or TAssignmentSingleField; + + /** + * INTERNAL: Do not use. + */ + class TAst = + TArraySpecification or TAttribute or TAttributeExpression or TAttributeList or + TAttributeLiteral or TCase or TCatch or TClassAccessModifier or TCompilationUnit or + TCrossCompany or TExpression or TFieldAssignment or TFieldSpecification or TForAssign or + TInsertFieldSpecification or TInstanceName or TJoinSpecification or TModifier or + TOrderElement or TQualifier or TQuery or TQueryDataSource or TQueryDataSourceHaving or + TQueryDataSourceRange or TQueryDataSourceRelation or TSelection or TSelectionField or + TStatement or TSwitchCase or TTableFieldReference or TValidTimeState or TXppType; + + /** + * INTERNAL: Do not use. + */ + class TAttributeLiteral = + TContainerAttributeLiteral or TDefaultTypeAttributeLiteral or TEnumAttributeLiteral or + TIntrinsicAttributeLiteral; + + /** + * INTERNAL: Do not use. + */ + class TBinaryExpression = + TAddExpression or TAndExpression or TDivideExpression or TInExpression or + TIntegerDivideExpression or TModExpression or TMultiplyExpression or TOrExpression or + TPhysicalAndExpression or TPhysicalOrExpression or TPhysicalXorExpression or + TRelationalExpression or TShiftLeftExpression or TShiftRightExpression or + TSubtractExpression; + + /** + * INTERNAL: Do not use. + */ + class TCase = TCaseDefault or TCaseValues; + + /** + * INTERNAL: Do not use. + */ + class TCatch = TCatchAllValues or TCatchExpression or TCatchUpdateConflict; + + /** + * INTERNAL: Do not use. + */ + class TChangeStatement = TChangeCompanyStatement; + + /** + * INTERNAL: Do not use. + */ + class TClassOrInterface = TClass or TInterface; + + /** + * INTERNAL: Do not use. + */ + class TCompilationUnit = + TDeclaration or TExpressionCompilationUnit or TMethodOrDelegate or TModelElement or + TXppTypeCompilationUnit; + + /** + * INTERNAL: Do not use. + */ + class TCrossCompany = TCrossCompanyAll or TCrossCompanyContainer; + + /** + * INTERNAL: Do not use. + */ + class TDeclaration = TFieldDeclaration or TLocalDeclaration; + + /** + * INTERNAL: Do not use. + */ + class TDefaultTypeAttributeLiteral = + TBooleanAttributeLiteral or TDateAttributeLiteral or TDateTimeAttributeLiteral or + TDblAttributeLiteral or TGuidAttributeLiteral or TInt64AttributeLiteral or + TIntAttributeLiteral or TStringAttributeLiteral; + + /** + * INTERNAL: Do not use. + */ + class TDefaultTypeLiteralExpression = + TBooleanLiteralExpression or TDateLiteralExpression or TDateTimeLiteralExpression or + TInt64LiteralExpression or TIntLiteralExpression or TRealLiteralExpression or + TStringLiteralExpression; + + /** + * INTERNAL: Do not use. + */ + class TErrorElement = TUnspecifiedElement; + + /** + * INTERNAL: Do not use. + */ + class TEvaluation = + TGenericEvaluation or TNewCall or TNextExpression or TProvidedTypeStaticCall or TSuperCall; + + /** + * INTERNAL: Do not use. + */ + class TExpression = + TBinaryExpression or TConditionalExpression or TEmptyExpression or TEvaluation or + TFieldExpression or TIntrinsic or TIsAsExpression or TLiteralExpression or + TNewClrArrayExpression or TPlaceholder or TTableLookupExpression or TUnaryExpression; + + /** + * INTERNAL: Do not use. + */ + class TFieldDeclaration = TFieldDeclarationInternal or TTableFieldDeclaration; + + /** + * INTERNAL: Do not use. + */ + class TFieldExpression = TFieldExpressionInternal or TQualifiedStaticFieldExpression; + + /** + * INTERNAL: Do not use. + */ + class TFieldSpecification = + TQualifiedField or TQualifiedNumberedField or TQualifiedStaticField or TSimpleField or + TStaticField; + + /** + * INTERNAL: Do not use. + */ + class TForAssign = + TForDeclarationAssign or TForExpressionAssign or TForFieldPostDecrement or + TForFieldPostIncrement or TForFieldPreDecrement or TForFieldPreIncrement; + + /** + * INTERNAL: Do not use. + */ + class TForExpressionAssign = + TForFieldAssign or TForFieldDecrementAssign or TForFieldIncrementAssign; + + /** + * INTERNAL: Do not use. + */ + class TFormNestedElement = TFormControl or TFormDataField or TFormDataSource; + + /** + * INTERNAL: Do not use. + */ + class TGenericEvaluation = + TFunctionCall or TNewClrCall or TQualifiedCall or TQualifiedStaticCall or TStaticMethodCall; + + /** + * INTERNAL: Do not use. + */ + class TGenericXppType = TClrType or TNamedType; + + /** + * INTERNAL: Do not use. + */ + class TInstanceName = TQualifiedInstanceName or TSimpleInstanceName; + + /** + * INTERNAL: Do not use. + */ + class TIsAsExpression = TAsClrExpression or TAsExpression or TIsClrExpression or TIsExpression; + + /** + * INTERNAL: Do not use. + */ + class TLiteralExpression = + TClrEnumerationLiteralExpression or TContainerLiteralExpression or + TDefaultTypeLiteralExpression or TEnumerationLiteralExpression or TNullLiteralExpression; + + /** + * INTERNAL: Do not use. + */ + class TLocalDeclaration = TFunctionDeclaration or TVariableDeclaration; + + /** + * INTERNAL: Do not use. + */ + class TLocatable = TAst or TComment or TErrorElement or TXppTuple; + + /** + * INTERNAL: Do not use. + */ + class TMethodOrDelegate = TDelegate or TMethod; + + /** + * INTERNAL: Do not use. + */ + class TModelElement = + TClassOrInterface or TFormModelElement or TFormNestedElement or TQueryModelElement or TTable; + + /** + * INTERNAL: Do not use. + */ + class TNamedType = TFormElementType or TNamedTypeInternal; + + /** + * INTERNAL: Do not use. + */ + class TOrderElement = TGlobalOrderElement or TSimpleOrderElement; + + /** + * INTERNAL: Do not use. + */ + class TQualifier = TExpressionQualifier or TSimpleQualifier; + + /** + * INTERNAL: Do not use. + */ + class TRelationalExpression = + TEqualExpression or TGreaterThanExpression or TGreaterThanOrEqualExpression or + TLessThanExpression or TLessThanOrEqualExpression or TLikeExpression or TNotEqualExpression; + + /** + * INTERNAL: Do not use. + */ + class TSelection = TAllFieldsSelection or TExplicitSelection or TImplicitSelection; + + /** + * INTERNAL: Do not use. + */ + class TSelectionField = TAggregateSelection or TFieldSelection; + + /** + * INTERNAL: Do not use. + */ + class TSimpleQualifier = TSimpleQualifierInternal or TStaticQualifier; + + /** + * INTERNAL: Do not use. + */ + class TStatement = + TAssignmentStatement or TBreakStatement or TBreakpointStatement or TChangeStatement or + TCompoundStatement or TContinueStatement or TDeleteStatement or TDoWhileStatement or + TEmptyStatement or TExpressionStatement or TFindStatement or TFlushStatement or + TForStatement or TIfStatement or TIfThenElseStatement or TInsertStatement or + TLocalDeclarationsStatement or TMoveCursorStatement or TPrintStatement or TRetryStatement or + TReturnStatement or TSearchStatement or TSwitchStatement or TThrowStatement or + TTryStatement or TTtsStatement or TUncheckedStatement or TUpdateStatement or + TUsingStatement or TWhileStatement; + + /** + * INTERNAL: Do not use. + */ + class TStringType = TStringLengthType or TStringTypeInternal; + + /** + * INTERNAL: Do not use. + */ + class TTableFieldReference = TNamedFieldReference or TNumberedFieldReference; + + /** + * INTERNAL: Do not use. + */ + class TTtsStatement = TTtsAbortStatement or TTtsBeginStatement or TTtsEndStatement; + + /** + * INTERNAL: Do not use. + */ + class TUnaryExpression = TNotExpression or TPhysicalNotExpression or TUnaryMinusExpression; + + /** + * INTERNAL: Do not use. + */ + class TValidTimeState = TValidTimeStateDate or TValidTimeStateRange; + + /** + * INTERNAL: Do not use. + */ + class TVariableDeclaration = TParameterDeclaration or TVariableDeclarationInternal; + + /** + * INTERNAL: Do not use. + */ + class TXppTuple = + TAttributeNamedParameterEntry or TCompilationUnitRegionEntry or + TEvaluationActualParameterEntry or TModelElementUsingEntry or TSwitchStatementCaseEntry or + TTryStatementCatchEntry; + + /** + * INTERNAL: Do not use. + */ + class TXppType = + TAnyType or TBooleanType or TContainerType or TDateTimeType or TDateType or TDblType or + TEnumerationType or TGenericXppType or TGuidType or TInt64Type or TIntType or + TProvidedType or TStringType or TVarType or TVoidType; + + /** + * INTERNAL: Do not use. + * + * Gets the parent of synthetic element `e`. + */ + Raw::Element getSynthParent(TElement e) { none() } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TAddExpression`, if possible. + */ + TAddExpression convertAddExpressionFromRaw(Raw::Element e) { result = TAddExpression(e) } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TAllFieldsSelection`, if possible. + */ + TAllFieldsSelection convertAllFieldsSelectionFromRaw(Raw::Element e) { + result = TAllFieldsSelection(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TAndExpression`, if possible. + */ + TAndExpression convertAndExpressionFromRaw(Raw::Element e) { result = TAndExpression(e) } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TAnyType`, if possible. + */ + TAnyType convertAnyTypeFromRaw(Raw::Element e) { result = TAnyType(e) } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TArraySpecification`, if possible. + */ + TArraySpecification convertArraySpecificationFromRaw(Raw::Element e) { + result = TArraySpecification(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TAsClrExpression`, if possible. + */ + TAsClrExpression convertAsClrExpressionFromRaw(Raw::Element e) { result = TAsClrExpression(e) } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TAsExpression`, if possible. + */ + TAsExpression convertAsExpressionFromRaw(Raw::Element e) { result = TAsExpression(e) } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TAssignDecrementStatement`, if possible. + */ + TAssignDecrementStatement convertAssignDecrementStatementFromRaw(Raw::Element e) { + result = TAssignDecrementStatement(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TAssignDivideStatement`, if possible. + */ + TAssignDivideStatement convertAssignDivideStatementFromRaw(Raw::Element e) { + result = TAssignDivideStatement(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TAssignEqualStatement`, if possible. + */ + TAssignEqualStatement convertAssignEqualStatementFromRaw(Raw::Element e) { + result = TAssignEqualStatement(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TAssignIncrementStatement`, if possible. + */ + TAssignIncrementStatement convertAssignIncrementStatementFromRaw(Raw::Element e) { + result = TAssignIncrementStatement(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TAssignMultipleFieldStatement`, if possible. + */ + TAssignMultipleFieldStatement convertAssignMultipleFieldStatementFromRaw(Raw::Element e) { + result = TAssignMultipleFieldStatement(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TAssignMultiplyStatement`, if possible. + */ + TAssignMultiplyStatement convertAssignMultiplyStatementFromRaw(Raw::Element e) { + result = TAssignMultiplyStatement(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TAssignPostDecrementStatement`, if possible. + */ + TAssignPostDecrementStatement convertAssignPostDecrementStatementFromRaw(Raw::Element e) { + result = TAssignPostDecrementStatement(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TAssignPostIncrementStatement`, if possible. + */ + TAssignPostIncrementStatement convertAssignPostIncrementStatementFromRaw(Raw::Element e) { + result = TAssignPostIncrementStatement(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TAssignPreDecrementStatement`, if possible. + */ + TAssignPreDecrementStatement convertAssignPreDecrementStatementFromRaw(Raw::Element e) { + result = TAssignPreDecrementStatement(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TAssignPreIncrementStatement`, if possible. + */ + TAssignPreIncrementStatement convertAssignPreIncrementStatementFromRaw(Raw::Element e) { + result = TAssignPreIncrementStatement(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TAssignmentEventHandlerClr`, if possible. + */ + TAssignmentEventHandlerClr convertAssignmentEventHandlerClrFromRaw(Raw::Element e) { + result = TAssignmentEventHandlerClr(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TAssignmentEventHandlerInstance`, if possible. + */ + TAssignmentEventHandlerInstance convertAssignmentEventHandlerInstanceFromRaw(Raw::Element e) { + result = TAssignmentEventHandlerInstance(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TAssignmentEventHandlerStaticInternal`, if possible. + */ + TAssignmentEventHandlerStaticInternal convertAssignmentEventHandlerStaticInternalFromRaw( + Raw::Element e + ) { + result = TAssignmentEventHandlerStaticInternal(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TAttribute`, if possible. + */ + TAttribute convertAttributeFromRaw(Raw::Element e) { result = TAttribute(e) } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TAttributeExpression`, if possible. + */ + TAttributeExpression convertAttributeExpressionFromRaw(Raw::Element e) { + result = TAttributeExpression(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TAttributeList`, if possible. + */ + TAttributeList convertAttributeListFromRaw(Raw::Element e) { result = TAttributeList(e) } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TAttributeNamedParameterEntry`, if possible. + */ + TAttributeNamedParameterEntry convertAttributeNamedParameterEntryFromRaw(Raw::Element e) { + result = TAttributeNamedParameterEntry(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TAvgAggregateSelection`, if possible. + */ + TAvgAggregateSelection convertAvgAggregateSelectionFromRaw(Raw::Element e) { + result = TAvgAggregateSelection(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TBooleanAttributeLiteral`, if possible. + */ + TBooleanAttributeLiteral convertBooleanAttributeLiteralFromRaw(Raw::Element e) { + result = TBooleanAttributeLiteral(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TBooleanLiteralExpression`, if possible. + */ + TBooleanLiteralExpression convertBooleanLiteralExpressionFromRaw(Raw::Element e) { + result = TBooleanLiteralExpression(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TBooleanType`, if possible. + */ + TBooleanType convertBooleanTypeFromRaw(Raw::Element e) { result = TBooleanType(e) } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TBreakStatement`, if possible. + */ + TBreakStatement convertBreakStatementFromRaw(Raw::Element e) { result = TBreakStatement(e) } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TBreakpointStatement`, if possible. + */ + TBreakpointStatement convertBreakpointStatementFromRaw(Raw::Element e) { + result = TBreakpointStatement(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TCaseDefault`, if possible. + */ + TCaseDefault convertCaseDefaultFromRaw(Raw::Element e) { result = TCaseDefault(e) } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TCaseValues`, if possible. + */ + TCaseValues convertCaseValuesFromRaw(Raw::Element e) { result = TCaseValues(e) } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TCatchAllValues`, if possible. + */ + TCatchAllValues convertCatchAllValuesFromRaw(Raw::Element e) { result = TCatchAllValues(e) } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TCatchExpression`, if possible. + */ + TCatchExpression convertCatchExpressionFromRaw(Raw::Element e) { result = TCatchExpression(e) } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TCatchUpdateConflict`, if possible. + */ + TCatchUpdateConflict convertCatchUpdateConflictFromRaw(Raw::Element e) { + result = TCatchUpdateConflict(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TChangeCompanyStatement`, if possible. + */ + TChangeCompanyStatement convertChangeCompanyStatementFromRaw(Raw::Element e) { + result = TChangeCompanyStatement(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TClass`, if possible. + */ + TClass convertClassFromRaw(Raw::Element e) { result = TClass(e) } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TClassAccessModifier`, if possible. + */ + TClassAccessModifier convertClassAccessModifierFromRaw(Raw::Element e) { + result = TClassAccessModifier(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TClrEnumerationLiteralExpression`, if possible. + */ + TClrEnumerationLiteralExpression convertClrEnumerationLiteralExpressionFromRaw(Raw::Element e) { + result = TClrEnumerationLiteralExpression(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TClrType`, if possible. + */ + TClrType convertClrTypeFromRaw(Raw::Element e) { result = TClrType(e) } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TComment`, if possible. + */ + TComment convertCommentFromRaw(Raw::Element e) { result = TComment(e) } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TCompilationUnitRegionEntry`, if possible. + */ + TCompilationUnitRegionEntry convertCompilationUnitRegionEntryFromRaw(Raw::Element e) { + result = TCompilationUnitRegionEntry(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TCompoundStatement`, if possible. + */ + TCompoundStatement convertCompoundStatementFromRaw(Raw::Element e) { + result = TCompoundStatement(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TConditionalExpression`, if possible. + */ + TConditionalExpression convertConditionalExpressionFromRaw(Raw::Element e) { + result = TConditionalExpression(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TContainerAttributeLiteral`, if possible. + */ + TContainerAttributeLiteral convertContainerAttributeLiteralFromRaw(Raw::Element e) { + result = TContainerAttributeLiteral(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TContainerLiteralExpression`, if possible. + */ + TContainerLiteralExpression convertContainerLiteralExpressionFromRaw(Raw::Element e) { + result = TContainerLiteralExpression(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TContainerType`, if possible. + */ + TContainerType convertContainerTypeFromRaw(Raw::Element e) { result = TContainerType(e) } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TContinueStatement`, if possible. + */ + TContinueStatement convertContinueStatementFromRaw(Raw::Element e) { + result = TContinueStatement(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TCountAggregateSelection`, if possible. + */ + TCountAggregateSelection convertCountAggregateSelectionFromRaw(Raw::Element e) { + result = TCountAggregateSelection(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TCrossCompanyAll`, if possible. + */ + TCrossCompanyAll convertCrossCompanyAllFromRaw(Raw::Element e) { result = TCrossCompanyAll(e) } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TCrossCompanyContainer`, if possible. + */ + TCrossCompanyContainer convertCrossCompanyContainerFromRaw(Raw::Element e) { + result = TCrossCompanyContainer(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TDateAttributeLiteral`, if possible. + */ + TDateAttributeLiteral convertDateAttributeLiteralFromRaw(Raw::Element e) { + result = TDateAttributeLiteral(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TDateLiteralExpression`, if possible. + */ + TDateLiteralExpression convertDateLiteralExpressionFromRaw(Raw::Element e) { + result = TDateLiteralExpression(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TDateTimeAttributeLiteral`, if possible. + */ + TDateTimeAttributeLiteral convertDateTimeAttributeLiteralFromRaw(Raw::Element e) { + result = TDateTimeAttributeLiteral(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TDateTimeLiteralExpression`, if possible. + */ + TDateTimeLiteralExpression convertDateTimeLiteralExpressionFromRaw(Raw::Element e) { + result = TDateTimeLiteralExpression(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TDateTimeType`, if possible. + */ + TDateTimeType convertDateTimeTypeFromRaw(Raw::Element e) { result = TDateTimeType(e) } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TDateType`, if possible. + */ + TDateType convertDateTypeFromRaw(Raw::Element e) { result = TDateType(e) } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TDblAttributeLiteral`, if possible. + */ + TDblAttributeLiteral convertDblAttributeLiteralFromRaw(Raw::Element e) { + result = TDblAttributeLiteral(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TDblType`, if possible. + */ + TDblType convertDblTypeFromRaw(Raw::Element e) { result = TDblType(e) } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TDelegate`, if possible. + */ + TDelegate convertDelegateFromRaw(Raw::Element e) { result = TDelegate(e) } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TDeleteStatement`, if possible. + */ + TDeleteStatement convertDeleteStatementFromRaw(Raw::Element e) { result = TDeleteStatement(e) } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TDivideExpression`, if possible. + */ + TDivideExpression convertDivideExpressionFromRaw(Raw::Element e) { result = TDivideExpression(e) } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TDoWhileStatement`, if possible. + */ + TDoWhileStatement convertDoWhileStatementFromRaw(Raw::Element e) { result = TDoWhileStatement(e) } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TEmptyExpression`, if possible. + */ + TEmptyExpression convertEmptyExpressionFromRaw(Raw::Element e) { result = TEmptyExpression(e) } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TEmptyStatement`, if possible. + */ + TEmptyStatement convertEmptyStatementFromRaw(Raw::Element e) { result = TEmptyStatement(e) } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TEnumAttributeLiteral`, if possible. + */ + TEnumAttributeLiteral convertEnumAttributeLiteralFromRaw(Raw::Element e) { + result = TEnumAttributeLiteral(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TEnumerationLiteralExpression`, if possible. + */ + TEnumerationLiteralExpression convertEnumerationLiteralExpressionFromRaw(Raw::Element e) { + result = TEnumerationLiteralExpression(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TEnumerationType`, if possible. + */ + TEnumerationType convertEnumerationTypeFromRaw(Raw::Element e) { result = TEnumerationType(e) } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TEqualExpression`, if possible. + */ + TEqualExpression convertEqualExpressionFromRaw(Raw::Element e) { result = TEqualExpression(e) } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TEvaluationActualParameterEntry`, if possible. + */ + TEvaluationActualParameterEntry convertEvaluationActualParameterEntryFromRaw(Raw::Element e) { + result = TEvaluationActualParameterEntry(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TExplicitSelection`, if possible. + */ + TExplicitSelection convertExplicitSelectionFromRaw(Raw::Element e) { + result = TExplicitSelection(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TExpressionCompilationUnit`, if possible. + */ + TExpressionCompilationUnit convertExpressionCompilationUnitFromRaw(Raw::Element e) { + result = TExpressionCompilationUnit(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TExpressionQualifier`, if possible. + */ + TExpressionQualifier convertExpressionQualifierFromRaw(Raw::Element e) { + result = TExpressionQualifier(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TExpressionStatement`, if possible. + */ + TExpressionStatement convertExpressionStatementFromRaw(Raw::Element e) { + result = TExpressionStatement(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TFieldAssignment`, if possible. + */ + TFieldAssignment convertFieldAssignmentFromRaw(Raw::Element e) { result = TFieldAssignment(e) } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TFieldDeclarationInternal`, if possible. + */ + TFieldDeclarationInternal convertFieldDeclarationInternalFromRaw(Raw::Element e) { + result = TFieldDeclarationInternal(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TFieldExpressionInternal`, if possible. + */ + TFieldExpressionInternal convertFieldExpressionInternalFromRaw(Raw::Element e) { + result = TFieldExpressionInternal(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TFieldSelection`, if possible. + */ + TFieldSelection convertFieldSelectionFromRaw(Raw::Element e) { result = TFieldSelection(e) } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TFile`, if possible. + */ + TFile convertFileFromRaw(Raw::Element e) { result = TFile(e) } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TFindStatement`, if possible. + */ + TFindStatement convertFindStatementFromRaw(Raw::Element e) { result = TFindStatement(e) } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TFlushStatement`, if possible. + */ + TFlushStatement convertFlushStatementFromRaw(Raw::Element e) { result = TFlushStatement(e) } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TForDeclarationAssign`, if possible. + */ + TForDeclarationAssign convertForDeclarationAssignFromRaw(Raw::Element e) { + result = TForDeclarationAssign(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TForFieldAssign`, if possible. + */ + TForFieldAssign convertForFieldAssignFromRaw(Raw::Element e) { result = TForFieldAssign(e) } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TForFieldDecrementAssign`, if possible. + */ + TForFieldDecrementAssign convertForFieldDecrementAssignFromRaw(Raw::Element e) { + result = TForFieldDecrementAssign(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TForFieldIncrementAssign`, if possible. + */ + TForFieldIncrementAssign convertForFieldIncrementAssignFromRaw(Raw::Element e) { + result = TForFieldIncrementAssign(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TForFieldPostDecrement`, if possible. + */ + TForFieldPostDecrement convertForFieldPostDecrementFromRaw(Raw::Element e) { + result = TForFieldPostDecrement(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TForFieldPostIncrement`, if possible. + */ + TForFieldPostIncrement convertForFieldPostIncrementFromRaw(Raw::Element e) { + result = TForFieldPostIncrement(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TForFieldPreDecrement`, if possible. + */ + TForFieldPreDecrement convertForFieldPreDecrementFromRaw(Raw::Element e) { + result = TForFieldPreDecrement(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TForFieldPreIncrement`, if possible. + */ + TForFieldPreIncrement convertForFieldPreIncrementFromRaw(Raw::Element e) { + result = TForFieldPreIncrement(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TForStatement`, if possible. + */ + TForStatement convertForStatementFromRaw(Raw::Element e) { result = TForStatement(e) } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TFormControl`, if possible. + */ + TFormControl convertFormControlFromRaw(Raw::Element e) { result = TFormControl(e) } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TFormDataField`, if possible. + */ + TFormDataField convertFormDataFieldFromRaw(Raw::Element e) { result = TFormDataField(e) } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TFormDataSource`, if possible. + */ + TFormDataSource convertFormDataSourceFromRaw(Raw::Element e) { result = TFormDataSource(e) } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TFormElementType`, if possible. + */ + TFormElementType convertFormElementTypeFromRaw(Raw::Element e) { result = TFormElementType(e) } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TFormModelElement`, if possible. + */ + TFormModelElement convertFormModelElementFromRaw(Raw::Element e) { result = TFormModelElement(e) } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TFunctionCall`, if possible. + */ + TFunctionCall convertFunctionCallFromRaw(Raw::Element e) { result = TFunctionCall(e) } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TFunctionDeclaration`, if possible. + */ + TFunctionDeclaration convertFunctionDeclarationFromRaw(Raw::Element e) { + result = TFunctionDeclaration(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TGlobalOrderElement`, if possible. + */ + TGlobalOrderElement convertGlobalOrderElementFromRaw(Raw::Element e) { + result = TGlobalOrderElement(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TGreaterThanExpression`, if possible. + */ + TGreaterThanExpression convertGreaterThanExpressionFromRaw(Raw::Element e) { + result = TGreaterThanExpression(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TGreaterThanOrEqualExpression`, if possible. + */ + TGreaterThanOrEqualExpression convertGreaterThanOrEqualExpressionFromRaw(Raw::Element e) { + result = TGreaterThanOrEqualExpression(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TGuidAttributeLiteral`, if possible. + */ + TGuidAttributeLiteral convertGuidAttributeLiteralFromRaw(Raw::Element e) { + result = TGuidAttributeLiteral(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TGuidType`, if possible. + */ + TGuidType convertGuidTypeFromRaw(Raw::Element e) { result = TGuidType(e) } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TIfStatement`, if possible. + */ + TIfStatement convertIfStatementFromRaw(Raw::Element e) { result = TIfStatement(e) } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TIfThenElseStatement`, if possible. + */ + TIfThenElseStatement convertIfThenElseStatementFromRaw(Raw::Element e) { + result = TIfThenElseStatement(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TImplicitSelection`, if possible. + */ + TImplicitSelection convertImplicitSelectionFromRaw(Raw::Element e) { + result = TImplicitSelection(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TInExpression`, if possible. + */ + TInExpression convertInExpressionFromRaw(Raw::Element e) { result = TInExpression(e) } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TInsertFieldSpecification`, if possible. + */ + TInsertFieldSpecification convertInsertFieldSpecificationFromRaw(Raw::Element e) { + result = TInsertFieldSpecification(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TInsertStatement`, if possible. + */ + TInsertStatement convertInsertStatementFromRaw(Raw::Element e) { result = TInsertStatement(e) } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TInt64AttributeLiteral`, if possible. + */ + TInt64AttributeLiteral convertInt64AttributeLiteralFromRaw(Raw::Element e) { + result = TInt64AttributeLiteral(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TInt64LiteralExpression`, if possible. + */ + TInt64LiteralExpression convertInt64LiteralExpressionFromRaw(Raw::Element e) { + result = TInt64LiteralExpression(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TInt64Type`, if possible. + */ + TInt64Type convertInt64TypeFromRaw(Raw::Element e) { result = TInt64Type(e) } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TIntAttributeLiteral`, if possible. + */ + TIntAttributeLiteral convertIntAttributeLiteralFromRaw(Raw::Element e) { + result = TIntAttributeLiteral(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TIntLiteralExpression`, if possible. + */ + TIntLiteralExpression convertIntLiteralExpressionFromRaw(Raw::Element e) { + result = TIntLiteralExpression(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TIntType`, if possible. + */ + TIntType convertIntTypeFromRaw(Raw::Element e) { result = TIntType(e) } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TIntegerDivideExpression`, if possible. + */ + TIntegerDivideExpression convertIntegerDivideExpressionFromRaw(Raw::Element e) { + result = TIntegerDivideExpression(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TInterface`, if possible. + */ + TInterface convertInterfaceFromRaw(Raw::Element e) { result = TInterface(e) } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TIntrinsic`, if possible. + */ + TIntrinsic convertIntrinsicFromRaw(Raw::Element e) { result = TIntrinsic(e) } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TIntrinsicAttributeLiteral`, if possible. + */ + TIntrinsicAttributeLiteral convertIntrinsicAttributeLiteralFromRaw(Raw::Element e) { + result = TIntrinsicAttributeLiteral(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TIsClrExpression`, if possible. + */ + TIsClrExpression convertIsClrExpressionFromRaw(Raw::Element e) { result = TIsClrExpression(e) } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TIsExpression`, if possible. + */ + TIsExpression convertIsExpressionFromRaw(Raw::Element e) { result = TIsExpression(e) } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TJoinSpecification`, if possible. + */ + TJoinSpecification convertJoinSpecificationFromRaw(Raw::Element e) { + result = TJoinSpecification(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TLessThanExpression`, if possible. + */ + TLessThanExpression convertLessThanExpressionFromRaw(Raw::Element e) { + result = TLessThanExpression(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TLessThanOrEqualExpression`, if possible. + */ + TLessThanOrEqualExpression convertLessThanOrEqualExpressionFromRaw(Raw::Element e) { + result = TLessThanOrEqualExpression(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TLikeExpression`, if possible. + */ + TLikeExpression convertLikeExpressionFromRaw(Raw::Element e) { result = TLikeExpression(e) } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TLocalDeclarationsStatement`, if possible. + */ + TLocalDeclarationsStatement convertLocalDeclarationsStatementFromRaw(Raw::Element e) { + result = TLocalDeclarationsStatement(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TLocation`, if possible. + */ + TLocation convertLocationFromRaw(Raw::Element e) { result = TLocation(e) } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TMaxAggregateSelection`, if possible. + */ + TMaxAggregateSelection convertMaxAggregateSelectionFromRaw(Raw::Element e) { + result = TMaxAggregateSelection(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TMethod`, if possible. + */ + TMethod convertMethodFromRaw(Raw::Element e) { result = TMethod(e) } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TMinAggregateSelection`, if possible. + */ + TMinAggregateSelection convertMinAggregateSelectionFromRaw(Raw::Element e) { + result = TMinAggregateSelection(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TModExpression`, if possible. + */ + TModExpression convertModExpressionFromRaw(Raw::Element e) { result = TModExpression(e) } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TModelElementUsingEntry`, if possible. + */ + TModelElementUsingEntry convertModelElementUsingEntryFromRaw(Raw::Element e) { + result = TModelElementUsingEntry(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TModifier`, if possible. + */ + TModifier convertModifierFromRaw(Raw::Element e) { result = TModifier(e) } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TMoveCursorStatement`, if possible. + */ + TMoveCursorStatement convertMoveCursorStatementFromRaw(Raw::Element e) { + result = TMoveCursorStatement(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TMultiplyExpression`, if possible. + */ + TMultiplyExpression convertMultiplyExpressionFromRaw(Raw::Element e) { + result = TMultiplyExpression(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TNamedFieldReference`, if possible. + */ + TNamedFieldReference convertNamedFieldReferenceFromRaw(Raw::Element e) { + result = TNamedFieldReference(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TNamedTypeInternal`, if possible. + */ + TNamedTypeInternal convertNamedTypeInternalFromRaw(Raw::Element e) { + result = TNamedTypeInternal(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TNewCall`, if possible. + */ + TNewCall convertNewCallFromRaw(Raw::Element e) { result = TNewCall(e) } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TNewClrArrayExpression`, if possible. + */ + TNewClrArrayExpression convertNewClrArrayExpressionFromRaw(Raw::Element e) { + result = TNewClrArrayExpression(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TNewClrCall`, if possible. + */ + TNewClrCall convertNewClrCallFromRaw(Raw::Element e) { result = TNewClrCall(e) } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TNextExpression`, if possible. + */ + TNextExpression convertNextExpressionFromRaw(Raw::Element e) { result = TNextExpression(e) } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TNotEqualExpression`, if possible. + */ + TNotEqualExpression convertNotEqualExpressionFromRaw(Raw::Element e) { + result = TNotEqualExpression(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TNotExpression`, if possible. + */ + TNotExpression convertNotExpressionFromRaw(Raw::Element e) { result = TNotExpression(e) } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TNullLiteralExpression`, if possible. + */ + TNullLiteralExpression convertNullLiteralExpressionFromRaw(Raw::Element e) { + result = TNullLiteralExpression(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TNumberedFieldReference`, if possible. + */ + TNumberedFieldReference convertNumberedFieldReferenceFromRaw(Raw::Element e) { + result = TNumberedFieldReference(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TOrExpression`, if possible. + */ + TOrExpression convertOrExpressionFromRaw(Raw::Element e) { result = TOrExpression(e) } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TParameterDeclaration`, if possible. + */ + TParameterDeclaration convertParameterDeclarationFromRaw(Raw::Element e) { + result = TParameterDeclaration(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TPhysicalAndExpression`, if possible. + */ + TPhysicalAndExpression convertPhysicalAndExpressionFromRaw(Raw::Element e) { + result = TPhysicalAndExpression(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TPhysicalNotExpression`, if possible. + */ + TPhysicalNotExpression convertPhysicalNotExpressionFromRaw(Raw::Element e) { + result = TPhysicalNotExpression(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TPhysicalOrExpression`, if possible. + */ + TPhysicalOrExpression convertPhysicalOrExpressionFromRaw(Raw::Element e) { + result = TPhysicalOrExpression(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TPhysicalXorExpression`, if possible. + */ + TPhysicalXorExpression convertPhysicalXorExpressionFromRaw(Raw::Element e) { + result = TPhysicalXorExpression(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TPlaceholder`, if possible. + */ + TPlaceholder convertPlaceholderFromRaw(Raw::Element e) { result = TPlaceholder(e) } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TPrintStatement`, if possible. + */ + TPrintStatement convertPrintStatementFromRaw(Raw::Element e) { result = TPrintStatement(e) } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TProvidedType`, if possible. + */ + TProvidedType convertProvidedTypeFromRaw(Raw::Element e) { result = TProvidedType(e) } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TProvidedTypeStaticCall`, if possible. + */ + TProvidedTypeStaticCall convertProvidedTypeStaticCallFromRaw(Raw::Element e) { + result = TProvidedTypeStaticCall(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TQualifiedCall`, if possible. + */ + TQualifiedCall convertQualifiedCallFromRaw(Raw::Element e) { result = TQualifiedCall(e) } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TQualifiedField`, if possible. + */ + TQualifiedField convertQualifiedFieldFromRaw(Raw::Element e) { result = TQualifiedField(e) } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TQualifiedInstanceName`, if possible. + */ + TQualifiedInstanceName convertQualifiedInstanceNameFromRaw(Raw::Element e) { + result = TQualifiedInstanceName(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TQualifiedNumberedField`, if possible. + */ + TQualifiedNumberedField convertQualifiedNumberedFieldFromRaw(Raw::Element e) { + result = TQualifiedNumberedField(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TQualifiedStaticCall`, if possible. + */ + TQualifiedStaticCall convertQualifiedStaticCallFromRaw(Raw::Element e) { + result = TQualifiedStaticCall(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TQualifiedStaticField`, if possible. + */ + TQualifiedStaticField convertQualifiedStaticFieldFromRaw(Raw::Element e) { + result = TQualifiedStaticField(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TQualifiedStaticFieldExpression`, if possible. + */ + TQualifiedStaticFieldExpression convertQualifiedStaticFieldExpressionFromRaw(Raw::Element e) { + result = TQualifiedStaticFieldExpression(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TQuery`, if possible. + */ + TQuery convertQueryFromRaw(Raw::Element e) { result = TQuery(e) } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TQueryDataSource`, if possible. + */ + TQueryDataSource convertQueryDataSourceFromRaw(Raw::Element e) { result = TQueryDataSource(e) } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TQueryDataSourceHaving`, if possible. + */ + TQueryDataSourceHaving convertQueryDataSourceHavingFromRaw(Raw::Element e) { + result = TQueryDataSourceHaving(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TQueryDataSourceRange`, if possible. + */ + TQueryDataSourceRange convertQueryDataSourceRangeFromRaw(Raw::Element e) { + result = TQueryDataSourceRange(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TQueryDataSourceRelation`, if possible. + */ + TQueryDataSourceRelation convertQueryDataSourceRelationFromRaw(Raw::Element e) { + result = TQueryDataSourceRelation(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TQueryModelElement`, if possible. + */ + TQueryModelElement convertQueryModelElementFromRaw(Raw::Element e) { + result = TQueryModelElement(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TRealLiteralExpression`, if possible. + */ + TRealLiteralExpression convertRealLiteralExpressionFromRaw(Raw::Element e) { + result = TRealLiteralExpression(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TRetryStatement`, if possible. + */ + TRetryStatement convertRetryStatementFromRaw(Raw::Element e) { result = TRetryStatement(e) } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TReturnStatement`, if possible. + */ + TReturnStatement convertReturnStatementFromRaw(Raw::Element e) { result = TReturnStatement(e) } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TSearchStatement`, if possible. + */ + TSearchStatement convertSearchStatementFromRaw(Raw::Element e) { result = TSearchStatement(e) } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TShiftLeftExpression`, if possible. + */ + TShiftLeftExpression convertShiftLeftExpressionFromRaw(Raw::Element e) { + result = TShiftLeftExpression(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TShiftRightExpression`, if possible. + */ + TShiftRightExpression convertShiftRightExpressionFromRaw(Raw::Element e) { + result = TShiftRightExpression(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TSimpleField`, if possible. + */ + TSimpleField convertSimpleFieldFromRaw(Raw::Element e) { result = TSimpleField(e) } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TSimpleInstanceName`, if possible. + */ + TSimpleInstanceName convertSimpleInstanceNameFromRaw(Raw::Element e) { + result = TSimpleInstanceName(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TSimpleOrderElement`, if possible. + */ + TSimpleOrderElement convertSimpleOrderElementFromRaw(Raw::Element e) { + result = TSimpleOrderElement(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TSimpleQualifierInternal`, if possible. + */ + TSimpleQualifierInternal convertSimpleQualifierInternalFromRaw(Raw::Element e) { + result = TSimpleQualifierInternal(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TStaticField`, if possible. + */ + TStaticField convertStaticFieldFromRaw(Raw::Element e) { result = TStaticField(e) } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TStaticMethodCall`, if possible. + */ + TStaticMethodCall convertStaticMethodCallFromRaw(Raw::Element e) { result = TStaticMethodCall(e) } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TStaticQualifier`, if possible. + */ + TStaticQualifier convertStaticQualifierFromRaw(Raw::Element e) { result = TStaticQualifier(e) } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TStringAttributeLiteral`, if possible. + */ + TStringAttributeLiteral convertStringAttributeLiteralFromRaw(Raw::Element e) { + result = TStringAttributeLiteral(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TStringLengthType`, if possible. + */ + TStringLengthType convertStringLengthTypeFromRaw(Raw::Element e) { result = TStringLengthType(e) } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TStringLiteralExpression`, if possible. + */ + TStringLiteralExpression convertStringLiteralExpressionFromRaw(Raw::Element e) { + result = TStringLiteralExpression(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TStringTypeInternal`, if possible. + */ + TStringTypeInternal convertStringTypeInternalFromRaw(Raw::Element e) { + result = TStringTypeInternal(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TSubtractExpression`, if possible. + */ + TSubtractExpression convertSubtractExpressionFromRaw(Raw::Element e) { + result = TSubtractExpression(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TSumAggregateSelection`, if possible. + */ + TSumAggregateSelection convertSumAggregateSelectionFromRaw(Raw::Element e) { + result = TSumAggregateSelection(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TSuperCall`, if possible. + */ + TSuperCall convertSuperCallFromRaw(Raw::Element e) { result = TSuperCall(e) } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TSwitchCase`, if possible. + */ + TSwitchCase convertSwitchCaseFromRaw(Raw::Element e) { result = TSwitchCase(e) } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TSwitchStatement`, if possible. + */ + TSwitchStatement convertSwitchStatementFromRaw(Raw::Element e) { result = TSwitchStatement(e) } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TSwitchStatementCaseEntry`, if possible. + */ + TSwitchStatementCaseEntry convertSwitchStatementCaseEntryFromRaw(Raw::Element e) { + result = TSwitchStatementCaseEntry(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TTable`, if possible. + */ + TTable convertTableFromRaw(Raw::Element e) { result = TTable(e) } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TTableFieldDeclaration`, if possible. + */ + TTableFieldDeclaration convertTableFieldDeclarationFromRaw(Raw::Element e) { + result = TTableFieldDeclaration(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TTableLookupExpression`, if possible. + */ + TTableLookupExpression convertTableLookupExpressionFromRaw(Raw::Element e) { + result = TTableLookupExpression(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TThrowStatement`, if possible. + */ + TThrowStatement convertThrowStatementFromRaw(Raw::Element e) { result = TThrowStatement(e) } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TTryStatement`, if possible. + */ + TTryStatement convertTryStatementFromRaw(Raw::Element e) { result = TTryStatement(e) } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TTryStatementCatchEntry`, if possible. + */ + TTryStatementCatchEntry convertTryStatementCatchEntryFromRaw(Raw::Element e) { + result = TTryStatementCatchEntry(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TTtsAbortStatement`, if possible. + */ + TTtsAbortStatement convertTtsAbortStatementFromRaw(Raw::Element e) { + result = TTtsAbortStatement(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TTtsBeginStatement`, if possible. + */ + TTtsBeginStatement convertTtsBeginStatementFromRaw(Raw::Element e) { + result = TTtsBeginStatement(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TTtsEndStatement`, if possible. + */ + TTtsEndStatement convertTtsEndStatementFromRaw(Raw::Element e) { result = TTtsEndStatement(e) } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TUnaryMinusExpression`, if possible. + */ + TUnaryMinusExpression convertUnaryMinusExpressionFromRaw(Raw::Element e) { + result = TUnaryMinusExpression(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TUncheckedStatement`, if possible. + */ + TUncheckedStatement convertUncheckedStatementFromRaw(Raw::Element e) { + result = TUncheckedStatement(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TUnspecifiedElement`, if possible. + */ + TUnspecifiedElement convertUnspecifiedElementFromRaw(Raw::Element e) { + result = TUnspecifiedElement(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TUpdateStatement`, if possible. + */ + TUpdateStatement convertUpdateStatementFromRaw(Raw::Element e) { result = TUpdateStatement(e) } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TUsingStatement`, if possible. + */ + TUsingStatement convertUsingStatementFromRaw(Raw::Element e) { result = TUsingStatement(e) } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TValidTimeStateDate`, if possible. + */ + TValidTimeStateDate convertValidTimeStateDateFromRaw(Raw::Element e) { + result = TValidTimeStateDate(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TValidTimeStateRange`, if possible. + */ + TValidTimeStateRange convertValidTimeStateRangeFromRaw(Raw::Element e) { + result = TValidTimeStateRange(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TVarType`, if possible. + */ + TVarType convertVarTypeFromRaw(Raw::Element e) { result = TVarType(e) } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TVariableDeclarationInternal`, if possible. + */ + TVariableDeclarationInternal convertVariableDeclarationInternalFromRaw(Raw::Element e) { + result = TVariableDeclarationInternal(e) + } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TVoidType`, if possible. + */ + TVoidType convertVoidTypeFromRaw(Raw::Element e) { result = TVoidType(e) } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TWhileStatement`, if possible. + */ + TWhileStatement convertWhileStatementFromRaw(Raw::Element e) { result = TWhileStatement(e) } + + /** + * INTERNAL: Do not use. + * + * Converts a raw element to a synthesized `TXppTypeCompilationUnit`, if possible. + */ + TXppTypeCompilationUnit convertXppTypeCompilationUnitFromRaw(Raw::Element e) { + result = TXppTypeCompilationUnit(e) + } + + /** + * INTERNAL: Do not use. + * Converts a raw DB element to a synthesized `TAggregateSelection`, if possible. + */ + TAggregateSelection convertAggregateSelectionFromRaw(Raw::Element e) { + result = convertAvgAggregateSelectionFromRaw(e) + or + result = convertCountAggregateSelectionFromRaw(e) + or + result = convertMaxAggregateSelectionFromRaw(e) + or + result = convertMinAggregateSelectionFromRaw(e) + or + result = convertSumAggregateSelectionFromRaw(e) + } + + /** + * INTERNAL: Do not use. + * Converts a raw DB element to a synthesized `TAssignmentBinary`, if possible. + */ + TAssignmentBinary convertAssignmentBinaryFromRaw(Raw::Element e) { + result = convertAssignDecrementStatementFromRaw(e) + or + result = convertAssignDivideStatementFromRaw(e) + or + result = convertAssignEqualStatementFromRaw(e) + or + result = convertAssignIncrementStatementFromRaw(e) + or + result = convertAssignMultiplyStatementFromRaw(e) + } + + /** + * INTERNAL: Do not use. + * Converts a raw DB element to a synthesized `TAssignmentEventHandlerBase`, if possible. + */ + TAssignmentEventHandlerBase convertAssignmentEventHandlerBaseFromRaw(Raw::Element e) { + result = convertAssignmentEventHandlerInstanceFromRaw(e) + or + result = convertAssignmentEventHandlerStaticFromRaw(e) + } + + /** + * INTERNAL: Do not use. + * Converts a raw DB element to a synthesized `TAssignmentEventHandlerStatic`, if possible. + */ + TAssignmentEventHandlerStatic convertAssignmentEventHandlerStaticFromRaw(Raw::Element e) { + result = convertAssignmentEventHandlerClrFromRaw(e) + or + result = convertAssignmentEventHandlerStaticInternalFromRaw(e) + } + + /** + * INTERNAL: Do not use. + * Converts a raw DB element to a synthesized `TAssignmentSingleField`, if possible. + */ + TAssignmentSingleField convertAssignmentSingleFieldFromRaw(Raw::Element e) { + result = convertAssignPostDecrementStatementFromRaw(e) + or + result = convertAssignPostIncrementStatementFromRaw(e) + or + result = convertAssignPreDecrementStatementFromRaw(e) + or + result = convertAssignPreIncrementStatementFromRaw(e) + or + result = convertAssignmentBinaryFromRaw(e) + or + result = convertAssignmentEventHandlerBaseFromRaw(e) + } + + /** + * INTERNAL: Do not use. + * Converts a raw DB element to a synthesized `TAssignmentStatement`, if possible. + */ + TAssignmentStatement convertAssignmentStatementFromRaw(Raw::Element e) { + result = convertAssignMultipleFieldStatementFromRaw(e) + or + result = convertAssignmentSingleFieldFromRaw(e) + } + + /** + * INTERNAL: Do not use. + * Converts a raw DB element to a synthesized `TAst`, if possible. + */ + TAst convertAstFromRaw(Raw::Element e) { + result = convertArraySpecificationFromRaw(e) + or + result = convertAttributeFromRaw(e) + or + result = convertAttributeExpressionFromRaw(e) + or + result = convertAttributeListFromRaw(e) + or + result = convertAttributeLiteralFromRaw(e) + or + result = convertCaseFromRaw(e) + or + result = convertCatchFromRaw(e) + or + result = convertClassAccessModifierFromRaw(e) + or + result = convertCompilationUnitFromRaw(e) + or + result = convertCrossCompanyFromRaw(e) + or + result = convertExpressionFromRaw(e) + or + result = convertFieldAssignmentFromRaw(e) + or + result = convertFieldSpecificationFromRaw(e) + or + result = convertForAssignFromRaw(e) + or + result = convertInsertFieldSpecificationFromRaw(e) + or + result = convertInstanceNameFromRaw(e) + or + result = convertJoinSpecificationFromRaw(e) + or + result = convertModifierFromRaw(e) + or + result = convertOrderElementFromRaw(e) + or + result = convertQualifierFromRaw(e) + or + result = convertQueryFromRaw(e) + or + result = convertQueryDataSourceFromRaw(e) + or + result = convertQueryDataSourceHavingFromRaw(e) + or + result = convertQueryDataSourceRangeFromRaw(e) + or + result = convertQueryDataSourceRelationFromRaw(e) + or + result = convertSelectionFromRaw(e) + or + result = convertSelectionFieldFromRaw(e) + or + result = convertStatementFromRaw(e) + or + result = convertSwitchCaseFromRaw(e) + or + result = convertTableFieldReferenceFromRaw(e) + or + result = convertValidTimeStateFromRaw(e) + or + result = convertXppTypeFromRaw(e) + } + + /** + * INTERNAL: Do not use. + * Converts a raw DB element to a synthesized `TAttributeLiteral`, if possible. + */ + TAttributeLiteral convertAttributeLiteralFromRaw(Raw::Element e) { + result = convertContainerAttributeLiteralFromRaw(e) + or + result = convertDefaultTypeAttributeLiteralFromRaw(e) + or + result = convertEnumAttributeLiteralFromRaw(e) + or + result = convertIntrinsicAttributeLiteralFromRaw(e) + } + + /** + * INTERNAL: Do not use. + * Converts a raw DB element to a synthesized `TBinaryExpression`, if possible. + */ + TBinaryExpression convertBinaryExpressionFromRaw(Raw::Element e) { + result = convertAddExpressionFromRaw(e) + or + result = convertAndExpressionFromRaw(e) + or + result = convertDivideExpressionFromRaw(e) + or + result = convertInExpressionFromRaw(e) + or + result = convertIntegerDivideExpressionFromRaw(e) + or + result = convertModExpressionFromRaw(e) + or + result = convertMultiplyExpressionFromRaw(e) + or + result = convertOrExpressionFromRaw(e) + or + result = convertPhysicalAndExpressionFromRaw(e) + or + result = convertPhysicalOrExpressionFromRaw(e) + or + result = convertPhysicalXorExpressionFromRaw(e) + or + result = convertRelationalExpressionFromRaw(e) + or + result = convertShiftLeftExpressionFromRaw(e) + or + result = convertShiftRightExpressionFromRaw(e) + or + result = convertSubtractExpressionFromRaw(e) + } + + /** + * INTERNAL: Do not use. + * Converts a raw DB element to a synthesized `TCase`, if possible. + */ + TCase convertCaseFromRaw(Raw::Element e) { + result = convertCaseDefaultFromRaw(e) + or + result = convertCaseValuesFromRaw(e) + } + + /** + * INTERNAL: Do not use. + * Converts a raw DB element to a synthesized `TCatch`, if possible. + */ + TCatch convertCatchFromRaw(Raw::Element e) { + result = convertCatchAllValuesFromRaw(e) + or + result = convertCatchExpressionFromRaw(e) + or + result = convertCatchUpdateConflictFromRaw(e) + } + + /** + * INTERNAL: Do not use. + * Converts a raw DB element to a synthesized `TChangeStatement`, if possible. + */ + TChangeStatement convertChangeStatementFromRaw(Raw::Element e) { + result = convertChangeCompanyStatementFromRaw(e) + } + + /** + * INTERNAL: Do not use. + * Converts a raw DB element to a synthesized `TClassOrInterface`, if possible. + */ + TClassOrInterface convertClassOrInterfaceFromRaw(Raw::Element e) { + result = convertClassFromRaw(e) + or + result = convertInterfaceFromRaw(e) + } + + /** + * INTERNAL: Do not use. + * Converts a raw DB element to a synthesized `TCompilationUnit`, if possible. + */ + TCompilationUnit convertCompilationUnitFromRaw(Raw::Element e) { + result = convertDeclarationFromRaw(e) + or + result = convertExpressionCompilationUnitFromRaw(e) + or + result = convertMethodOrDelegateFromRaw(e) + or + result = convertModelElementFromRaw(e) + or + result = convertXppTypeCompilationUnitFromRaw(e) + } + + /** + * INTERNAL: Do not use. + * Converts a raw DB element to a synthesized `TCrossCompany`, if possible. + */ + TCrossCompany convertCrossCompanyFromRaw(Raw::Element e) { + result = convertCrossCompanyAllFromRaw(e) + or + result = convertCrossCompanyContainerFromRaw(e) + } + + /** + * INTERNAL: Do not use. + * Converts a raw DB element to a synthesized `TDeclaration`, if possible. + */ + TDeclaration convertDeclarationFromRaw(Raw::Element e) { + result = convertFieldDeclarationFromRaw(e) + or + result = convertLocalDeclarationFromRaw(e) + } + + /** + * INTERNAL: Do not use. + * Converts a raw DB element to a synthesized `TDefaultTypeAttributeLiteral`, if possible. + */ + TDefaultTypeAttributeLiteral convertDefaultTypeAttributeLiteralFromRaw(Raw::Element e) { + result = convertBooleanAttributeLiteralFromRaw(e) + or + result = convertDateAttributeLiteralFromRaw(e) + or + result = convertDateTimeAttributeLiteralFromRaw(e) + or + result = convertDblAttributeLiteralFromRaw(e) + or + result = convertGuidAttributeLiteralFromRaw(e) + or + result = convertInt64AttributeLiteralFromRaw(e) + or + result = convertIntAttributeLiteralFromRaw(e) + or + result = convertStringAttributeLiteralFromRaw(e) + } + + /** + * INTERNAL: Do not use. + * Converts a raw DB element to a synthesized `TDefaultTypeLiteralExpression`, if possible. + */ + TDefaultTypeLiteralExpression convertDefaultTypeLiteralExpressionFromRaw(Raw::Element e) { + result = convertBooleanLiteralExpressionFromRaw(e) + or + result = convertDateLiteralExpressionFromRaw(e) + or + result = convertDateTimeLiteralExpressionFromRaw(e) + or + result = convertInt64LiteralExpressionFromRaw(e) + or + result = convertIntLiteralExpressionFromRaw(e) + or + result = convertRealLiteralExpressionFromRaw(e) + or + result = convertStringLiteralExpressionFromRaw(e) + } + + /** + * INTERNAL: Do not use. + * Converts a raw DB element to a synthesized `TElement`, if possible. + */ + TElement convertElementFromRaw(Raw::Element e) { + result = convertFileFromRaw(e) + or + result = convertLocatableFromRaw(e) + or + result = convertLocationFromRaw(e) + } + + /** + * INTERNAL: Do not use. + * Converts a raw DB element to a synthesized `TErrorElement`, if possible. + */ + TErrorElement convertErrorElementFromRaw(Raw::Element e) { + result = convertUnspecifiedElementFromRaw(e) + } + + /** + * INTERNAL: Do not use. + * Converts a raw DB element to a synthesized `TEvaluation`, if possible. + */ + TEvaluation convertEvaluationFromRaw(Raw::Element e) { + result = convertGenericEvaluationFromRaw(e) + or + result = convertNewCallFromRaw(e) + or + result = convertNextExpressionFromRaw(e) + or + result = convertProvidedTypeStaticCallFromRaw(e) + or + result = convertSuperCallFromRaw(e) + } + + /** + * INTERNAL: Do not use. + * Converts a raw DB element to a synthesized `TExpression`, if possible. + */ + TExpression convertExpressionFromRaw(Raw::Element e) { + result = convertBinaryExpressionFromRaw(e) + or + result = convertConditionalExpressionFromRaw(e) + or + result = convertEmptyExpressionFromRaw(e) + or + result = convertEvaluationFromRaw(e) + or + result = convertFieldExpressionFromRaw(e) + or + result = convertIntrinsicFromRaw(e) + or + result = convertIsAsExpressionFromRaw(e) + or + result = convertLiteralExpressionFromRaw(e) + or + result = convertNewClrArrayExpressionFromRaw(e) + or + result = convertPlaceholderFromRaw(e) + or + result = convertTableLookupExpressionFromRaw(e) + or + result = convertUnaryExpressionFromRaw(e) + } + + /** + * INTERNAL: Do not use. + * Converts a raw DB element to a synthesized `TFieldDeclaration`, if possible. + */ + TFieldDeclaration convertFieldDeclarationFromRaw(Raw::Element e) { + result = convertFieldDeclarationInternalFromRaw(e) + or + result = convertTableFieldDeclarationFromRaw(e) + } + + /** + * INTERNAL: Do not use. + * Converts a raw DB element to a synthesized `TFieldExpression`, if possible. + */ + TFieldExpression convertFieldExpressionFromRaw(Raw::Element e) { + result = convertFieldExpressionInternalFromRaw(e) + or + result = convertQualifiedStaticFieldExpressionFromRaw(e) + } + + /** + * INTERNAL: Do not use. + * Converts a raw DB element to a synthesized `TFieldSpecification`, if possible. + */ + TFieldSpecification convertFieldSpecificationFromRaw(Raw::Element e) { + result = convertQualifiedFieldFromRaw(e) + or + result = convertQualifiedNumberedFieldFromRaw(e) + or + result = convertQualifiedStaticFieldFromRaw(e) + or + result = convertSimpleFieldFromRaw(e) + or + result = convertStaticFieldFromRaw(e) + } + + /** + * INTERNAL: Do not use. + * Converts a raw DB element to a synthesized `TForAssign`, if possible. + */ + TForAssign convertForAssignFromRaw(Raw::Element e) { + result = convertForDeclarationAssignFromRaw(e) + or + result = convertForExpressionAssignFromRaw(e) + or + result = convertForFieldPostDecrementFromRaw(e) + or + result = convertForFieldPostIncrementFromRaw(e) + or + result = convertForFieldPreDecrementFromRaw(e) + or + result = convertForFieldPreIncrementFromRaw(e) + } + + /** + * INTERNAL: Do not use. + * Converts a raw DB element to a synthesized `TForExpressionAssign`, if possible. + */ + TForExpressionAssign convertForExpressionAssignFromRaw(Raw::Element e) { + result = convertForFieldAssignFromRaw(e) + or + result = convertForFieldDecrementAssignFromRaw(e) + or + result = convertForFieldIncrementAssignFromRaw(e) + } + + /** + * INTERNAL: Do not use. + * Converts a raw DB element to a synthesized `TFormNestedElement`, if possible. + */ + TFormNestedElement convertFormNestedElementFromRaw(Raw::Element e) { + result = convertFormControlFromRaw(e) + or + result = convertFormDataFieldFromRaw(e) + or + result = convertFormDataSourceFromRaw(e) + } + + /** + * INTERNAL: Do not use. + * Converts a raw DB element to a synthesized `TGenericEvaluation`, if possible. + */ + TGenericEvaluation convertGenericEvaluationFromRaw(Raw::Element e) { + result = convertFunctionCallFromRaw(e) + or + result = convertNewClrCallFromRaw(e) + or + result = convertQualifiedCallFromRaw(e) + or + result = convertQualifiedStaticCallFromRaw(e) + or + result = convertStaticMethodCallFromRaw(e) + } + + /** + * INTERNAL: Do not use. + * Converts a raw DB element to a synthesized `TGenericXppType`, if possible. + */ + TGenericXppType convertGenericXppTypeFromRaw(Raw::Element e) { + result = convertClrTypeFromRaw(e) + or + result = convertNamedTypeFromRaw(e) + } + + /** + * INTERNAL: Do not use. + * Converts a raw DB element to a synthesized `TInstanceName`, if possible. + */ + TInstanceName convertInstanceNameFromRaw(Raw::Element e) { + result = convertQualifiedInstanceNameFromRaw(e) + or + result = convertSimpleInstanceNameFromRaw(e) + } + + /** + * INTERNAL: Do not use. + * Converts a raw DB element to a synthesized `TIsAsExpression`, if possible. + */ + TIsAsExpression convertIsAsExpressionFromRaw(Raw::Element e) { + result = convertAsClrExpressionFromRaw(e) + or + result = convertAsExpressionFromRaw(e) + or + result = convertIsClrExpressionFromRaw(e) + or + result = convertIsExpressionFromRaw(e) + } + + /** + * INTERNAL: Do not use. + * Converts a raw DB element to a synthesized `TLiteralExpression`, if possible. + */ + TLiteralExpression convertLiteralExpressionFromRaw(Raw::Element e) { + result = convertClrEnumerationLiteralExpressionFromRaw(e) + or + result = convertContainerLiteralExpressionFromRaw(e) + or + result = convertDefaultTypeLiteralExpressionFromRaw(e) + or + result = convertEnumerationLiteralExpressionFromRaw(e) + or + result = convertNullLiteralExpressionFromRaw(e) + } + + /** + * INTERNAL: Do not use. + * Converts a raw DB element to a synthesized `TLocalDeclaration`, if possible. + */ + TLocalDeclaration convertLocalDeclarationFromRaw(Raw::Element e) { + result = convertFunctionDeclarationFromRaw(e) + or + result = convertVariableDeclarationFromRaw(e) + } + + /** + * INTERNAL: Do not use. + * Converts a raw DB element to a synthesized `TLocatable`, if possible. + */ + TLocatable convertLocatableFromRaw(Raw::Element e) { + result = convertAstFromRaw(e) + or + result = convertCommentFromRaw(e) + or + result = convertErrorElementFromRaw(e) + or + result = convertXppTupleFromRaw(e) + } + + /** + * INTERNAL: Do not use. + * Converts a raw DB element to a synthesized `TMethodOrDelegate`, if possible. + */ + TMethodOrDelegate convertMethodOrDelegateFromRaw(Raw::Element e) { + result = convertDelegateFromRaw(e) + or + result = convertMethodFromRaw(e) + } + + /** + * INTERNAL: Do not use. + * Converts a raw DB element to a synthesized `TModelElement`, if possible. + */ + TModelElement convertModelElementFromRaw(Raw::Element e) { + result = convertClassOrInterfaceFromRaw(e) + or + result = convertFormModelElementFromRaw(e) + or + result = convertFormNestedElementFromRaw(e) + or + result = convertQueryModelElementFromRaw(e) + or + result = convertTableFromRaw(e) + } + + /** + * INTERNAL: Do not use. + * Converts a raw DB element to a synthesized `TNamedType`, if possible. + */ + TNamedType convertNamedTypeFromRaw(Raw::Element e) { + result = convertFormElementTypeFromRaw(e) + or + result = convertNamedTypeInternalFromRaw(e) + } + + /** + * INTERNAL: Do not use. + * Converts a raw DB element to a synthesized `TOrderElement`, if possible. + */ + TOrderElement convertOrderElementFromRaw(Raw::Element e) { + result = convertGlobalOrderElementFromRaw(e) + or + result = convertSimpleOrderElementFromRaw(e) + } + + /** + * INTERNAL: Do not use. + * Converts a raw DB element to a synthesized `TQualifier`, if possible. + */ + TQualifier convertQualifierFromRaw(Raw::Element e) { + result = convertExpressionQualifierFromRaw(e) + or + result = convertSimpleQualifierFromRaw(e) + } + + /** + * INTERNAL: Do not use. + * Converts a raw DB element to a synthesized `TRelationalExpression`, if possible. + */ + TRelationalExpression convertRelationalExpressionFromRaw(Raw::Element e) { + result = convertEqualExpressionFromRaw(e) + or + result = convertGreaterThanExpressionFromRaw(e) + or + result = convertGreaterThanOrEqualExpressionFromRaw(e) + or + result = convertLessThanExpressionFromRaw(e) + or + result = convertLessThanOrEqualExpressionFromRaw(e) + or + result = convertLikeExpressionFromRaw(e) + or + result = convertNotEqualExpressionFromRaw(e) + } + + /** + * INTERNAL: Do not use. + * Converts a raw DB element to a synthesized `TSelection`, if possible. + */ + TSelection convertSelectionFromRaw(Raw::Element e) { + result = convertAllFieldsSelectionFromRaw(e) + or + result = convertExplicitSelectionFromRaw(e) + or + result = convertImplicitSelectionFromRaw(e) + } + + /** + * INTERNAL: Do not use. + * Converts a raw DB element to a synthesized `TSelectionField`, if possible. + */ + TSelectionField convertSelectionFieldFromRaw(Raw::Element e) { + result = convertAggregateSelectionFromRaw(e) + or + result = convertFieldSelectionFromRaw(e) + } + + /** + * INTERNAL: Do not use. + * Converts a raw DB element to a synthesized `TSimpleQualifier`, if possible. + */ + TSimpleQualifier convertSimpleQualifierFromRaw(Raw::Element e) { + result = convertSimpleQualifierInternalFromRaw(e) + or + result = convertStaticQualifierFromRaw(e) + } + + /** + * INTERNAL: Do not use. + * Converts a raw DB element to a synthesized `TStatement`, if possible. + */ + TStatement convertStatementFromRaw(Raw::Element e) { + result = convertAssignmentStatementFromRaw(e) + or + result = convertBreakStatementFromRaw(e) + or + result = convertBreakpointStatementFromRaw(e) + or + result = convertChangeStatementFromRaw(e) + or + result = convertCompoundStatementFromRaw(e) + or + result = convertContinueStatementFromRaw(e) + or + result = convertDeleteStatementFromRaw(e) + or + result = convertDoWhileStatementFromRaw(e) + or + result = convertEmptyStatementFromRaw(e) + or + result = convertExpressionStatementFromRaw(e) + or + result = convertFindStatementFromRaw(e) + or + result = convertFlushStatementFromRaw(e) + or + result = convertForStatementFromRaw(e) + or + result = convertIfStatementFromRaw(e) + or + result = convertIfThenElseStatementFromRaw(e) + or + result = convertInsertStatementFromRaw(e) + or + result = convertLocalDeclarationsStatementFromRaw(e) + or + result = convertMoveCursorStatementFromRaw(e) + or + result = convertPrintStatementFromRaw(e) + or + result = convertRetryStatementFromRaw(e) + or + result = convertReturnStatementFromRaw(e) + or + result = convertSearchStatementFromRaw(e) + or + result = convertSwitchStatementFromRaw(e) + or + result = convertThrowStatementFromRaw(e) + or + result = convertTryStatementFromRaw(e) + or + result = convertTtsStatementFromRaw(e) + or + result = convertUncheckedStatementFromRaw(e) + or + result = convertUpdateStatementFromRaw(e) + or + result = convertUsingStatementFromRaw(e) + or + result = convertWhileStatementFromRaw(e) + } + + /** + * INTERNAL: Do not use. + * Converts a raw DB element to a synthesized `TStringType`, if possible. + */ + TStringType convertStringTypeFromRaw(Raw::Element e) { + result = convertStringLengthTypeFromRaw(e) + or + result = convertStringTypeInternalFromRaw(e) + } + + /** + * INTERNAL: Do not use. + * Converts a raw DB element to a synthesized `TTableFieldReference`, if possible. + */ + TTableFieldReference convertTableFieldReferenceFromRaw(Raw::Element e) { + result = convertNamedFieldReferenceFromRaw(e) + or + result = convertNumberedFieldReferenceFromRaw(e) + } + + /** + * INTERNAL: Do not use. + * Converts a raw DB element to a synthesized `TTtsStatement`, if possible. + */ + TTtsStatement convertTtsStatementFromRaw(Raw::Element e) { + result = convertTtsAbortStatementFromRaw(e) + or + result = convertTtsBeginStatementFromRaw(e) + or + result = convertTtsEndStatementFromRaw(e) + } + + /** + * INTERNAL: Do not use. + * Converts a raw DB element to a synthesized `TUnaryExpression`, if possible. + */ + TUnaryExpression convertUnaryExpressionFromRaw(Raw::Element e) { + result = convertNotExpressionFromRaw(e) + or + result = convertPhysicalNotExpressionFromRaw(e) + or + result = convertUnaryMinusExpressionFromRaw(e) + } + + /** + * INTERNAL: Do not use. + * Converts a raw DB element to a synthesized `TValidTimeState`, if possible. + */ + TValidTimeState convertValidTimeStateFromRaw(Raw::Element e) { + result = convertValidTimeStateDateFromRaw(e) + or + result = convertValidTimeStateRangeFromRaw(e) + } + + /** + * INTERNAL: Do not use. + * Converts a raw DB element to a synthesized `TVariableDeclaration`, if possible. + */ + TVariableDeclaration convertVariableDeclarationFromRaw(Raw::Element e) { + result = convertParameterDeclarationFromRaw(e) + or + result = convertVariableDeclarationInternalFromRaw(e) + } + + /** + * INTERNAL: Do not use. + * Converts a raw DB element to a synthesized `TXppTuple`, if possible. + */ + TXppTuple convertXppTupleFromRaw(Raw::Element e) { + result = convertAttributeNamedParameterEntryFromRaw(e) + or + result = convertCompilationUnitRegionEntryFromRaw(e) + or + result = convertEvaluationActualParameterEntryFromRaw(e) + or + result = convertModelElementUsingEntryFromRaw(e) + or + result = convertSwitchStatementCaseEntryFromRaw(e) + or + result = convertTryStatementCatchEntryFromRaw(e) + } + + /** + * INTERNAL: Do not use. + * Converts a raw DB element to a synthesized `TXppType`, if possible. + */ + TXppType convertXppTypeFromRaw(Raw::Element e) { + result = convertAnyTypeFromRaw(e) + or + result = convertBooleanTypeFromRaw(e) + or + result = convertContainerTypeFromRaw(e) + or + result = convertDateTimeTypeFromRaw(e) + or + result = convertDateTypeFromRaw(e) + or + result = convertDblTypeFromRaw(e) + or + result = convertEnumerationTypeFromRaw(e) + or + result = convertGenericXppTypeFromRaw(e) + or + result = convertGuidTypeFromRaw(e) + or + result = convertInt64TypeFromRaw(e) + or + result = convertIntTypeFromRaw(e) + or + result = convertProvidedTypeFromRaw(e) + or + result = convertStringTypeFromRaw(e) + or + result = convertVarTypeFromRaw(e) + or + result = convertVoidTypeFromRaw(e) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TAddExpression` to a raw DB element, if possible. + */ + Raw::Element convertAddExpressionToRaw(TAddExpression e) { e = TAddExpression(result) } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TAllFieldsSelection` to a raw DB element, if possible. + */ + Raw::Element convertAllFieldsSelectionToRaw(TAllFieldsSelection e) { + e = TAllFieldsSelection(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TAndExpression` to a raw DB element, if possible. + */ + Raw::Element convertAndExpressionToRaw(TAndExpression e) { e = TAndExpression(result) } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TAnyType` to a raw DB element, if possible. + */ + Raw::Element convertAnyTypeToRaw(TAnyType e) { e = TAnyType(result) } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TArraySpecification` to a raw DB element, if possible. + */ + Raw::Element convertArraySpecificationToRaw(TArraySpecification e) { + e = TArraySpecification(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TAsClrExpression` to a raw DB element, if possible. + */ + Raw::Element convertAsClrExpressionToRaw(TAsClrExpression e) { e = TAsClrExpression(result) } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TAsExpression` to a raw DB element, if possible. + */ + Raw::Element convertAsExpressionToRaw(TAsExpression e) { e = TAsExpression(result) } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TAssignDecrementStatement` to a raw DB element, if possible. + */ + Raw::Element convertAssignDecrementStatementToRaw(TAssignDecrementStatement e) { + e = TAssignDecrementStatement(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TAssignDivideStatement` to a raw DB element, if possible. + */ + Raw::Element convertAssignDivideStatementToRaw(TAssignDivideStatement e) { + e = TAssignDivideStatement(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TAssignEqualStatement` to a raw DB element, if possible. + */ + Raw::Element convertAssignEqualStatementToRaw(TAssignEqualStatement e) { + e = TAssignEqualStatement(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TAssignIncrementStatement` to a raw DB element, if possible. + */ + Raw::Element convertAssignIncrementStatementToRaw(TAssignIncrementStatement e) { + e = TAssignIncrementStatement(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TAssignMultipleFieldStatement` to a raw DB element, if possible. + */ + Raw::Element convertAssignMultipleFieldStatementToRaw(TAssignMultipleFieldStatement e) { + e = TAssignMultipleFieldStatement(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TAssignMultiplyStatement` to a raw DB element, if possible. + */ + Raw::Element convertAssignMultiplyStatementToRaw(TAssignMultiplyStatement e) { + e = TAssignMultiplyStatement(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TAssignPostDecrementStatement` to a raw DB element, if possible. + */ + Raw::Element convertAssignPostDecrementStatementToRaw(TAssignPostDecrementStatement e) { + e = TAssignPostDecrementStatement(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TAssignPostIncrementStatement` to a raw DB element, if possible. + */ + Raw::Element convertAssignPostIncrementStatementToRaw(TAssignPostIncrementStatement e) { + e = TAssignPostIncrementStatement(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TAssignPreDecrementStatement` to a raw DB element, if possible. + */ + Raw::Element convertAssignPreDecrementStatementToRaw(TAssignPreDecrementStatement e) { + e = TAssignPreDecrementStatement(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TAssignPreIncrementStatement` to a raw DB element, if possible. + */ + Raw::Element convertAssignPreIncrementStatementToRaw(TAssignPreIncrementStatement e) { + e = TAssignPreIncrementStatement(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TAssignmentEventHandlerClr` to a raw DB element, if possible. + */ + Raw::Element convertAssignmentEventHandlerClrToRaw(TAssignmentEventHandlerClr e) { + e = TAssignmentEventHandlerClr(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TAssignmentEventHandlerInstance` to a raw DB element, if possible. + */ + Raw::Element convertAssignmentEventHandlerInstanceToRaw(TAssignmentEventHandlerInstance e) { + e = TAssignmentEventHandlerInstance(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TAssignmentEventHandlerStaticInternal` to a raw DB element, if possible. + */ + Raw::Element convertAssignmentEventHandlerStaticInternalToRaw( + TAssignmentEventHandlerStaticInternal e + ) { + e = TAssignmentEventHandlerStaticInternal(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TAttribute` to a raw DB element, if possible. + */ + Raw::Element convertAttributeToRaw(TAttribute e) { e = TAttribute(result) } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TAttributeExpression` to a raw DB element, if possible. + */ + Raw::Element convertAttributeExpressionToRaw(TAttributeExpression e) { + e = TAttributeExpression(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TAttributeList` to a raw DB element, if possible. + */ + Raw::Element convertAttributeListToRaw(TAttributeList e) { e = TAttributeList(result) } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TAttributeNamedParameterEntry` to a raw DB element, if possible. + */ + Raw::Element convertAttributeNamedParameterEntryToRaw(TAttributeNamedParameterEntry e) { + e = TAttributeNamedParameterEntry(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TAvgAggregateSelection` to a raw DB element, if possible. + */ + Raw::Element convertAvgAggregateSelectionToRaw(TAvgAggregateSelection e) { + e = TAvgAggregateSelection(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TBooleanAttributeLiteral` to a raw DB element, if possible. + */ + Raw::Element convertBooleanAttributeLiteralToRaw(TBooleanAttributeLiteral e) { + e = TBooleanAttributeLiteral(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TBooleanLiteralExpression` to a raw DB element, if possible. + */ + Raw::Element convertBooleanLiteralExpressionToRaw(TBooleanLiteralExpression e) { + e = TBooleanLiteralExpression(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TBooleanType` to a raw DB element, if possible. + */ + Raw::Element convertBooleanTypeToRaw(TBooleanType e) { e = TBooleanType(result) } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TBreakStatement` to a raw DB element, if possible. + */ + Raw::Element convertBreakStatementToRaw(TBreakStatement e) { e = TBreakStatement(result) } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TBreakpointStatement` to a raw DB element, if possible. + */ + Raw::Element convertBreakpointStatementToRaw(TBreakpointStatement e) { + e = TBreakpointStatement(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TCaseDefault` to a raw DB element, if possible. + */ + Raw::Element convertCaseDefaultToRaw(TCaseDefault e) { e = TCaseDefault(result) } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TCaseValues` to a raw DB element, if possible. + */ + Raw::Element convertCaseValuesToRaw(TCaseValues e) { e = TCaseValues(result) } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TCatchAllValues` to a raw DB element, if possible. + */ + Raw::Element convertCatchAllValuesToRaw(TCatchAllValues e) { e = TCatchAllValues(result) } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TCatchExpression` to a raw DB element, if possible. + */ + Raw::Element convertCatchExpressionToRaw(TCatchExpression e) { e = TCatchExpression(result) } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TCatchUpdateConflict` to a raw DB element, if possible. + */ + Raw::Element convertCatchUpdateConflictToRaw(TCatchUpdateConflict e) { + e = TCatchUpdateConflict(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TChangeCompanyStatement` to a raw DB element, if possible. + */ + Raw::Element convertChangeCompanyStatementToRaw(TChangeCompanyStatement e) { + e = TChangeCompanyStatement(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TClass` to a raw DB element, if possible. + */ + Raw::Element convertClassToRaw(TClass e) { e = TClass(result) } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TClassAccessModifier` to a raw DB element, if possible. + */ + Raw::Element convertClassAccessModifierToRaw(TClassAccessModifier e) { + e = TClassAccessModifier(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TClrEnumerationLiteralExpression` to a raw DB element, if possible. + */ + Raw::Element convertClrEnumerationLiteralExpressionToRaw(TClrEnumerationLiteralExpression e) { + e = TClrEnumerationLiteralExpression(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TClrType` to a raw DB element, if possible. + */ + Raw::Element convertClrTypeToRaw(TClrType e) { e = TClrType(result) } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TComment` to a raw DB element, if possible. + */ + Raw::Element convertCommentToRaw(TComment e) { e = TComment(result) } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TCompilationUnitRegionEntry` to a raw DB element, if possible. + */ + Raw::Element convertCompilationUnitRegionEntryToRaw(TCompilationUnitRegionEntry e) { + e = TCompilationUnitRegionEntry(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TCompoundStatement` to a raw DB element, if possible. + */ + Raw::Element convertCompoundStatementToRaw(TCompoundStatement e) { + e = TCompoundStatement(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TConditionalExpression` to a raw DB element, if possible. + */ + Raw::Element convertConditionalExpressionToRaw(TConditionalExpression e) { + e = TConditionalExpression(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TContainerAttributeLiteral` to a raw DB element, if possible. + */ + Raw::Element convertContainerAttributeLiteralToRaw(TContainerAttributeLiteral e) { + e = TContainerAttributeLiteral(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TContainerLiteralExpression` to a raw DB element, if possible. + */ + Raw::Element convertContainerLiteralExpressionToRaw(TContainerLiteralExpression e) { + e = TContainerLiteralExpression(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TContainerType` to a raw DB element, if possible. + */ + Raw::Element convertContainerTypeToRaw(TContainerType e) { e = TContainerType(result) } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TContinueStatement` to a raw DB element, if possible. + */ + Raw::Element convertContinueStatementToRaw(TContinueStatement e) { + e = TContinueStatement(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TCountAggregateSelection` to a raw DB element, if possible. + */ + Raw::Element convertCountAggregateSelectionToRaw(TCountAggregateSelection e) { + e = TCountAggregateSelection(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TCrossCompanyAll` to a raw DB element, if possible. + */ + Raw::Element convertCrossCompanyAllToRaw(TCrossCompanyAll e) { e = TCrossCompanyAll(result) } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TCrossCompanyContainer` to a raw DB element, if possible. + */ + Raw::Element convertCrossCompanyContainerToRaw(TCrossCompanyContainer e) { + e = TCrossCompanyContainer(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TDateAttributeLiteral` to a raw DB element, if possible. + */ + Raw::Element convertDateAttributeLiteralToRaw(TDateAttributeLiteral e) { + e = TDateAttributeLiteral(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TDateLiteralExpression` to a raw DB element, if possible. + */ + Raw::Element convertDateLiteralExpressionToRaw(TDateLiteralExpression e) { + e = TDateLiteralExpression(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TDateTimeAttributeLiteral` to a raw DB element, if possible. + */ + Raw::Element convertDateTimeAttributeLiteralToRaw(TDateTimeAttributeLiteral e) { + e = TDateTimeAttributeLiteral(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TDateTimeLiteralExpression` to a raw DB element, if possible. + */ + Raw::Element convertDateTimeLiteralExpressionToRaw(TDateTimeLiteralExpression e) { + e = TDateTimeLiteralExpression(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TDateTimeType` to a raw DB element, if possible. + */ + Raw::Element convertDateTimeTypeToRaw(TDateTimeType e) { e = TDateTimeType(result) } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TDateType` to a raw DB element, if possible. + */ + Raw::Element convertDateTypeToRaw(TDateType e) { e = TDateType(result) } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TDblAttributeLiteral` to a raw DB element, if possible. + */ + Raw::Element convertDblAttributeLiteralToRaw(TDblAttributeLiteral e) { + e = TDblAttributeLiteral(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TDblType` to a raw DB element, if possible. + */ + Raw::Element convertDblTypeToRaw(TDblType e) { e = TDblType(result) } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TDelegate` to a raw DB element, if possible. + */ + Raw::Element convertDelegateToRaw(TDelegate e) { e = TDelegate(result) } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TDeleteStatement` to a raw DB element, if possible. + */ + Raw::Element convertDeleteStatementToRaw(TDeleteStatement e) { e = TDeleteStatement(result) } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TDivideExpression` to a raw DB element, if possible. + */ + Raw::Element convertDivideExpressionToRaw(TDivideExpression e) { e = TDivideExpression(result) } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TDoWhileStatement` to a raw DB element, if possible. + */ + Raw::Element convertDoWhileStatementToRaw(TDoWhileStatement e) { e = TDoWhileStatement(result) } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TEmptyExpression` to a raw DB element, if possible. + */ + Raw::Element convertEmptyExpressionToRaw(TEmptyExpression e) { e = TEmptyExpression(result) } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TEmptyStatement` to a raw DB element, if possible. + */ + Raw::Element convertEmptyStatementToRaw(TEmptyStatement e) { e = TEmptyStatement(result) } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TEnumAttributeLiteral` to a raw DB element, if possible. + */ + Raw::Element convertEnumAttributeLiteralToRaw(TEnumAttributeLiteral e) { + e = TEnumAttributeLiteral(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TEnumerationLiteralExpression` to a raw DB element, if possible. + */ + Raw::Element convertEnumerationLiteralExpressionToRaw(TEnumerationLiteralExpression e) { + e = TEnumerationLiteralExpression(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TEnumerationType` to a raw DB element, if possible. + */ + Raw::Element convertEnumerationTypeToRaw(TEnumerationType e) { e = TEnumerationType(result) } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TEqualExpression` to a raw DB element, if possible. + */ + Raw::Element convertEqualExpressionToRaw(TEqualExpression e) { e = TEqualExpression(result) } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TEvaluationActualParameterEntry` to a raw DB element, if possible. + */ + Raw::Element convertEvaluationActualParameterEntryToRaw(TEvaluationActualParameterEntry e) { + e = TEvaluationActualParameterEntry(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TExplicitSelection` to a raw DB element, if possible. + */ + Raw::Element convertExplicitSelectionToRaw(TExplicitSelection e) { + e = TExplicitSelection(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TExpressionCompilationUnit` to a raw DB element, if possible. + */ + Raw::Element convertExpressionCompilationUnitToRaw(TExpressionCompilationUnit e) { + e = TExpressionCompilationUnit(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TExpressionQualifier` to a raw DB element, if possible. + */ + Raw::Element convertExpressionQualifierToRaw(TExpressionQualifier e) { + e = TExpressionQualifier(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TExpressionStatement` to a raw DB element, if possible. + */ + Raw::Element convertExpressionStatementToRaw(TExpressionStatement e) { + e = TExpressionStatement(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TFieldAssignment` to a raw DB element, if possible. + */ + Raw::Element convertFieldAssignmentToRaw(TFieldAssignment e) { e = TFieldAssignment(result) } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TFieldDeclarationInternal` to a raw DB element, if possible. + */ + Raw::Element convertFieldDeclarationInternalToRaw(TFieldDeclarationInternal e) { + e = TFieldDeclarationInternal(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TFieldExpressionInternal` to a raw DB element, if possible. + */ + Raw::Element convertFieldExpressionInternalToRaw(TFieldExpressionInternal e) { + e = TFieldExpressionInternal(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TFieldSelection` to a raw DB element, if possible. + */ + Raw::Element convertFieldSelectionToRaw(TFieldSelection e) { e = TFieldSelection(result) } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TFile` to a raw DB element, if possible. + */ + Raw::Element convertFileToRaw(TFile e) { e = TFile(result) } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TFindStatement` to a raw DB element, if possible. + */ + Raw::Element convertFindStatementToRaw(TFindStatement e) { e = TFindStatement(result) } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TFlushStatement` to a raw DB element, if possible. + */ + Raw::Element convertFlushStatementToRaw(TFlushStatement e) { e = TFlushStatement(result) } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TForDeclarationAssign` to a raw DB element, if possible. + */ + Raw::Element convertForDeclarationAssignToRaw(TForDeclarationAssign e) { + e = TForDeclarationAssign(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TForFieldAssign` to a raw DB element, if possible. + */ + Raw::Element convertForFieldAssignToRaw(TForFieldAssign e) { e = TForFieldAssign(result) } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TForFieldDecrementAssign` to a raw DB element, if possible. + */ + Raw::Element convertForFieldDecrementAssignToRaw(TForFieldDecrementAssign e) { + e = TForFieldDecrementAssign(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TForFieldIncrementAssign` to a raw DB element, if possible. + */ + Raw::Element convertForFieldIncrementAssignToRaw(TForFieldIncrementAssign e) { + e = TForFieldIncrementAssign(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TForFieldPostDecrement` to a raw DB element, if possible. + */ + Raw::Element convertForFieldPostDecrementToRaw(TForFieldPostDecrement e) { + e = TForFieldPostDecrement(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TForFieldPostIncrement` to a raw DB element, if possible. + */ + Raw::Element convertForFieldPostIncrementToRaw(TForFieldPostIncrement e) { + e = TForFieldPostIncrement(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TForFieldPreDecrement` to a raw DB element, if possible. + */ + Raw::Element convertForFieldPreDecrementToRaw(TForFieldPreDecrement e) { + e = TForFieldPreDecrement(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TForFieldPreIncrement` to a raw DB element, if possible. + */ + Raw::Element convertForFieldPreIncrementToRaw(TForFieldPreIncrement e) { + e = TForFieldPreIncrement(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TForStatement` to a raw DB element, if possible. + */ + Raw::Element convertForStatementToRaw(TForStatement e) { e = TForStatement(result) } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TFormControl` to a raw DB element, if possible. + */ + Raw::Element convertFormControlToRaw(TFormControl e) { e = TFormControl(result) } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TFormDataField` to a raw DB element, if possible. + */ + Raw::Element convertFormDataFieldToRaw(TFormDataField e) { e = TFormDataField(result) } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TFormDataSource` to a raw DB element, if possible. + */ + Raw::Element convertFormDataSourceToRaw(TFormDataSource e) { e = TFormDataSource(result) } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TFormElementType` to a raw DB element, if possible. + */ + Raw::Element convertFormElementTypeToRaw(TFormElementType e) { e = TFormElementType(result) } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TFormModelElement` to a raw DB element, if possible. + */ + Raw::Element convertFormModelElementToRaw(TFormModelElement e) { e = TFormModelElement(result) } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TFunctionCall` to a raw DB element, if possible. + */ + Raw::Element convertFunctionCallToRaw(TFunctionCall e) { e = TFunctionCall(result) } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TFunctionDeclaration` to a raw DB element, if possible. + */ + Raw::Element convertFunctionDeclarationToRaw(TFunctionDeclaration e) { + e = TFunctionDeclaration(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TGlobalOrderElement` to a raw DB element, if possible. + */ + Raw::Element convertGlobalOrderElementToRaw(TGlobalOrderElement e) { + e = TGlobalOrderElement(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TGreaterThanExpression` to a raw DB element, if possible. + */ + Raw::Element convertGreaterThanExpressionToRaw(TGreaterThanExpression e) { + e = TGreaterThanExpression(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TGreaterThanOrEqualExpression` to a raw DB element, if possible. + */ + Raw::Element convertGreaterThanOrEqualExpressionToRaw(TGreaterThanOrEqualExpression e) { + e = TGreaterThanOrEqualExpression(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TGuidAttributeLiteral` to a raw DB element, if possible. + */ + Raw::Element convertGuidAttributeLiteralToRaw(TGuidAttributeLiteral e) { + e = TGuidAttributeLiteral(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TGuidType` to a raw DB element, if possible. + */ + Raw::Element convertGuidTypeToRaw(TGuidType e) { e = TGuidType(result) } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TIfStatement` to a raw DB element, if possible. + */ + Raw::Element convertIfStatementToRaw(TIfStatement e) { e = TIfStatement(result) } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TIfThenElseStatement` to a raw DB element, if possible. + */ + Raw::Element convertIfThenElseStatementToRaw(TIfThenElseStatement e) { + e = TIfThenElseStatement(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TImplicitSelection` to a raw DB element, if possible. + */ + Raw::Element convertImplicitSelectionToRaw(TImplicitSelection e) { + e = TImplicitSelection(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TInExpression` to a raw DB element, if possible. + */ + Raw::Element convertInExpressionToRaw(TInExpression e) { e = TInExpression(result) } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TInsertFieldSpecification` to a raw DB element, if possible. + */ + Raw::Element convertInsertFieldSpecificationToRaw(TInsertFieldSpecification e) { + e = TInsertFieldSpecification(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TInsertStatement` to a raw DB element, if possible. + */ + Raw::Element convertInsertStatementToRaw(TInsertStatement e) { e = TInsertStatement(result) } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TInt64AttributeLiteral` to a raw DB element, if possible. + */ + Raw::Element convertInt64AttributeLiteralToRaw(TInt64AttributeLiteral e) { + e = TInt64AttributeLiteral(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TInt64LiteralExpression` to a raw DB element, if possible. + */ + Raw::Element convertInt64LiteralExpressionToRaw(TInt64LiteralExpression e) { + e = TInt64LiteralExpression(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TInt64Type` to a raw DB element, if possible. + */ + Raw::Element convertInt64TypeToRaw(TInt64Type e) { e = TInt64Type(result) } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TIntAttributeLiteral` to a raw DB element, if possible. + */ + Raw::Element convertIntAttributeLiteralToRaw(TIntAttributeLiteral e) { + e = TIntAttributeLiteral(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TIntLiteralExpression` to a raw DB element, if possible. + */ + Raw::Element convertIntLiteralExpressionToRaw(TIntLiteralExpression e) { + e = TIntLiteralExpression(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TIntType` to a raw DB element, if possible. + */ + Raw::Element convertIntTypeToRaw(TIntType e) { e = TIntType(result) } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TIntegerDivideExpression` to a raw DB element, if possible. + */ + Raw::Element convertIntegerDivideExpressionToRaw(TIntegerDivideExpression e) { + e = TIntegerDivideExpression(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TInterface` to a raw DB element, if possible. + */ + Raw::Element convertInterfaceToRaw(TInterface e) { e = TInterface(result) } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TIntrinsic` to a raw DB element, if possible. + */ + Raw::Element convertIntrinsicToRaw(TIntrinsic e) { e = TIntrinsic(result) } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TIntrinsicAttributeLiteral` to a raw DB element, if possible. + */ + Raw::Element convertIntrinsicAttributeLiteralToRaw(TIntrinsicAttributeLiteral e) { + e = TIntrinsicAttributeLiteral(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TIsClrExpression` to a raw DB element, if possible. + */ + Raw::Element convertIsClrExpressionToRaw(TIsClrExpression e) { e = TIsClrExpression(result) } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TIsExpression` to a raw DB element, if possible. + */ + Raw::Element convertIsExpressionToRaw(TIsExpression e) { e = TIsExpression(result) } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TJoinSpecification` to a raw DB element, if possible. + */ + Raw::Element convertJoinSpecificationToRaw(TJoinSpecification e) { + e = TJoinSpecification(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TLessThanExpression` to a raw DB element, if possible. + */ + Raw::Element convertLessThanExpressionToRaw(TLessThanExpression e) { + e = TLessThanExpression(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TLessThanOrEqualExpression` to a raw DB element, if possible. + */ + Raw::Element convertLessThanOrEqualExpressionToRaw(TLessThanOrEqualExpression e) { + e = TLessThanOrEqualExpression(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TLikeExpression` to a raw DB element, if possible. + */ + Raw::Element convertLikeExpressionToRaw(TLikeExpression e) { e = TLikeExpression(result) } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TLocalDeclarationsStatement` to a raw DB element, if possible. + */ + Raw::Element convertLocalDeclarationsStatementToRaw(TLocalDeclarationsStatement e) { + e = TLocalDeclarationsStatement(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TLocation` to a raw DB element, if possible. + */ + Raw::Element convertLocationToRaw(TLocation e) { e = TLocation(result) } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TMaxAggregateSelection` to a raw DB element, if possible. + */ + Raw::Element convertMaxAggregateSelectionToRaw(TMaxAggregateSelection e) { + e = TMaxAggregateSelection(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TMethod` to a raw DB element, if possible. + */ + Raw::Element convertMethodToRaw(TMethod e) { e = TMethod(result) } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TMinAggregateSelection` to a raw DB element, if possible. + */ + Raw::Element convertMinAggregateSelectionToRaw(TMinAggregateSelection e) { + e = TMinAggregateSelection(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TModExpression` to a raw DB element, if possible. + */ + Raw::Element convertModExpressionToRaw(TModExpression e) { e = TModExpression(result) } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TModelElementUsingEntry` to a raw DB element, if possible. + */ + Raw::Element convertModelElementUsingEntryToRaw(TModelElementUsingEntry e) { + e = TModelElementUsingEntry(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TModifier` to a raw DB element, if possible. + */ + Raw::Element convertModifierToRaw(TModifier e) { e = TModifier(result) } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TMoveCursorStatement` to a raw DB element, if possible. + */ + Raw::Element convertMoveCursorStatementToRaw(TMoveCursorStatement e) { + e = TMoveCursorStatement(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TMultiplyExpression` to a raw DB element, if possible. + */ + Raw::Element convertMultiplyExpressionToRaw(TMultiplyExpression e) { + e = TMultiplyExpression(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TNamedFieldReference` to a raw DB element, if possible. + */ + Raw::Element convertNamedFieldReferenceToRaw(TNamedFieldReference e) { + e = TNamedFieldReference(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TNamedTypeInternal` to a raw DB element, if possible. + */ + Raw::Element convertNamedTypeInternalToRaw(TNamedTypeInternal e) { + e = TNamedTypeInternal(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TNewCall` to a raw DB element, if possible. + */ + Raw::Element convertNewCallToRaw(TNewCall e) { e = TNewCall(result) } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TNewClrArrayExpression` to a raw DB element, if possible. + */ + Raw::Element convertNewClrArrayExpressionToRaw(TNewClrArrayExpression e) { + e = TNewClrArrayExpression(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TNewClrCall` to a raw DB element, if possible. + */ + Raw::Element convertNewClrCallToRaw(TNewClrCall e) { e = TNewClrCall(result) } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TNextExpression` to a raw DB element, if possible. + */ + Raw::Element convertNextExpressionToRaw(TNextExpression e) { e = TNextExpression(result) } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TNotEqualExpression` to a raw DB element, if possible. + */ + Raw::Element convertNotEqualExpressionToRaw(TNotEqualExpression e) { + e = TNotEqualExpression(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TNotExpression` to a raw DB element, if possible. + */ + Raw::Element convertNotExpressionToRaw(TNotExpression e) { e = TNotExpression(result) } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TNullLiteralExpression` to a raw DB element, if possible. + */ + Raw::Element convertNullLiteralExpressionToRaw(TNullLiteralExpression e) { + e = TNullLiteralExpression(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TNumberedFieldReference` to a raw DB element, if possible. + */ + Raw::Element convertNumberedFieldReferenceToRaw(TNumberedFieldReference e) { + e = TNumberedFieldReference(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TOrExpression` to a raw DB element, if possible. + */ + Raw::Element convertOrExpressionToRaw(TOrExpression e) { e = TOrExpression(result) } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TParameterDeclaration` to a raw DB element, if possible. + */ + Raw::Element convertParameterDeclarationToRaw(TParameterDeclaration e) { + e = TParameterDeclaration(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TPhysicalAndExpression` to a raw DB element, if possible. + */ + Raw::Element convertPhysicalAndExpressionToRaw(TPhysicalAndExpression e) { + e = TPhysicalAndExpression(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TPhysicalNotExpression` to a raw DB element, if possible. + */ + Raw::Element convertPhysicalNotExpressionToRaw(TPhysicalNotExpression e) { + e = TPhysicalNotExpression(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TPhysicalOrExpression` to a raw DB element, if possible. + */ + Raw::Element convertPhysicalOrExpressionToRaw(TPhysicalOrExpression e) { + e = TPhysicalOrExpression(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TPhysicalXorExpression` to a raw DB element, if possible. + */ + Raw::Element convertPhysicalXorExpressionToRaw(TPhysicalXorExpression e) { + e = TPhysicalXorExpression(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TPlaceholder` to a raw DB element, if possible. + */ + Raw::Element convertPlaceholderToRaw(TPlaceholder e) { e = TPlaceholder(result) } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TPrintStatement` to a raw DB element, if possible. + */ + Raw::Element convertPrintStatementToRaw(TPrintStatement e) { e = TPrintStatement(result) } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TProvidedType` to a raw DB element, if possible. + */ + Raw::Element convertProvidedTypeToRaw(TProvidedType e) { e = TProvidedType(result) } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TProvidedTypeStaticCall` to a raw DB element, if possible. + */ + Raw::Element convertProvidedTypeStaticCallToRaw(TProvidedTypeStaticCall e) { + e = TProvidedTypeStaticCall(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TQualifiedCall` to a raw DB element, if possible. + */ + Raw::Element convertQualifiedCallToRaw(TQualifiedCall e) { e = TQualifiedCall(result) } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TQualifiedField` to a raw DB element, if possible. + */ + Raw::Element convertQualifiedFieldToRaw(TQualifiedField e) { e = TQualifiedField(result) } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TQualifiedInstanceName` to a raw DB element, if possible. + */ + Raw::Element convertQualifiedInstanceNameToRaw(TQualifiedInstanceName e) { + e = TQualifiedInstanceName(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TQualifiedNumberedField` to a raw DB element, if possible. + */ + Raw::Element convertQualifiedNumberedFieldToRaw(TQualifiedNumberedField e) { + e = TQualifiedNumberedField(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TQualifiedStaticCall` to a raw DB element, if possible. + */ + Raw::Element convertQualifiedStaticCallToRaw(TQualifiedStaticCall e) { + e = TQualifiedStaticCall(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TQualifiedStaticField` to a raw DB element, if possible. + */ + Raw::Element convertQualifiedStaticFieldToRaw(TQualifiedStaticField e) { + e = TQualifiedStaticField(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TQualifiedStaticFieldExpression` to a raw DB element, if possible. + */ + Raw::Element convertQualifiedStaticFieldExpressionToRaw(TQualifiedStaticFieldExpression e) { + e = TQualifiedStaticFieldExpression(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TQuery` to a raw DB element, if possible. + */ + Raw::Element convertQueryToRaw(TQuery e) { e = TQuery(result) } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TQueryDataSource` to a raw DB element, if possible. + */ + Raw::Element convertQueryDataSourceToRaw(TQueryDataSource e) { e = TQueryDataSource(result) } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TQueryDataSourceHaving` to a raw DB element, if possible. + */ + Raw::Element convertQueryDataSourceHavingToRaw(TQueryDataSourceHaving e) { + e = TQueryDataSourceHaving(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TQueryDataSourceRange` to a raw DB element, if possible. + */ + Raw::Element convertQueryDataSourceRangeToRaw(TQueryDataSourceRange e) { + e = TQueryDataSourceRange(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TQueryDataSourceRelation` to a raw DB element, if possible. + */ + Raw::Element convertQueryDataSourceRelationToRaw(TQueryDataSourceRelation e) { + e = TQueryDataSourceRelation(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TQueryModelElement` to a raw DB element, if possible. + */ + Raw::Element convertQueryModelElementToRaw(TQueryModelElement e) { + e = TQueryModelElement(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TRealLiteralExpression` to a raw DB element, if possible. + */ + Raw::Element convertRealLiteralExpressionToRaw(TRealLiteralExpression e) { + e = TRealLiteralExpression(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TRetryStatement` to a raw DB element, if possible. + */ + Raw::Element convertRetryStatementToRaw(TRetryStatement e) { e = TRetryStatement(result) } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TReturnStatement` to a raw DB element, if possible. + */ + Raw::Element convertReturnStatementToRaw(TReturnStatement e) { e = TReturnStatement(result) } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TSearchStatement` to a raw DB element, if possible. + */ + Raw::Element convertSearchStatementToRaw(TSearchStatement e) { e = TSearchStatement(result) } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TShiftLeftExpression` to a raw DB element, if possible. + */ + Raw::Element convertShiftLeftExpressionToRaw(TShiftLeftExpression e) { + e = TShiftLeftExpression(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TShiftRightExpression` to a raw DB element, if possible. + */ + Raw::Element convertShiftRightExpressionToRaw(TShiftRightExpression e) { + e = TShiftRightExpression(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TSimpleField` to a raw DB element, if possible. + */ + Raw::Element convertSimpleFieldToRaw(TSimpleField e) { e = TSimpleField(result) } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TSimpleInstanceName` to a raw DB element, if possible. + */ + Raw::Element convertSimpleInstanceNameToRaw(TSimpleInstanceName e) { + e = TSimpleInstanceName(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TSimpleOrderElement` to a raw DB element, if possible. + */ + Raw::Element convertSimpleOrderElementToRaw(TSimpleOrderElement e) { + e = TSimpleOrderElement(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TSimpleQualifierInternal` to a raw DB element, if possible. + */ + Raw::Element convertSimpleQualifierInternalToRaw(TSimpleQualifierInternal e) { + e = TSimpleQualifierInternal(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TStaticField` to a raw DB element, if possible. + */ + Raw::Element convertStaticFieldToRaw(TStaticField e) { e = TStaticField(result) } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TStaticMethodCall` to a raw DB element, if possible. + */ + Raw::Element convertStaticMethodCallToRaw(TStaticMethodCall e) { e = TStaticMethodCall(result) } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TStaticQualifier` to a raw DB element, if possible. + */ + Raw::Element convertStaticQualifierToRaw(TStaticQualifier e) { e = TStaticQualifier(result) } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TStringAttributeLiteral` to a raw DB element, if possible. + */ + Raw::Element convertStringAttributeLiteralToRaw(TStringAttributeLiteral e) { + e = TStringAttributeLiteral(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TStringLengthType` to a raw DB element, if possible. + */ + Raw::Element convertStringLengthTypeToRaw(TStringLengthType e) { e = TStringLengthType(result) } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TStringLiteralExpression` to a raw DB element, if possible. + */ + Raw::Element convertStringLiteralExpressionToRaw(TStringLiteralExpression e) { + e = TStringLiteralExpression(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TStringTypeInternal` to a raw DB element, if possible. + */ + Raw::Element convertStringTypeInternalToRaw(TStringTypeInternal e) { + e = TStringTypeInternal(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TSubtractExpression` to a raw DB element, if possible. + */ + Raw::Element convertSubtractExpressionToRaw(TSubtractExpression e) { + e = TSubtractExpression(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TSumAggregateSelection` to a raw DB element, if possible. + */ + Raw::Element convertSumAggregateSelectionToRaw(TSumAggregateSelection e) { + e = TSumAggregateSelection(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TSuperCall` to a raw DB element, if possible. + */ + Raw::Element convertSuperCallToRaw(TSuperCall e) { e = TSuperCall(result) } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TSwitchCase` to a raw DB element, if possible. + */ + Raw::Element convertSwitchCaseToRaw(TSwitchCase e) { e = TSwitchCase(result) } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TSwitchStatement` to a raw DB element, if possible. + */ + Raw::Element convertSwitchStatementToRaw(TSwitchStatement e) { e = TSwitchStatement(result) } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TSwitchStatementCaseEntry` to a raw DB element, if possible. + */ + Raw::Element convertSwitchStatementCaseEntryToRaw(TSwitchStatementCaseEntry e) { + e = TSwitchStatementCaseEntry(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TTable` to a raw DB element, if possible. + */ + Raw::Element convertTableToRaw(TTable e) { e = TTable(result) } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TTableFieldDeclaration` to a raw DB element, if possible. + */ + Raw::Element convertTableFieldDeclarationToRaw(TTableFieldDeclaration e) { + e = TTableFieldDeclaration(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TTableLookupExpression` to a raw DB element, if possible. + */ + Raw::Element convertTableLookupExpressionToRaw(TTableLookupExpression e) { + e = TTableLookupExpression(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TThrowStatement` to a raw DB element, if possible. + */ + Raw::Element convertThrowStatementToRaw(TThrowStatement e) { e = TThrowStatement(result) } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TTryStatement` to a raw DB element, if possible. + */ + Raw::Element convertTryStatementToRaw(TTryStatement e) { e = TTryStatement(result) } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TTryStatementCatchEntry` to a raw DB element, if possible. + */ + Raw::Element convertTryStatementCatchEntryToRaw(TTryStatementCatchEntry e) { + e = TTryStatementCatchEntry(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TTtsAbortStatement` to a raw DB element, if possible. + */ + Raw::Element convertTtsAbortStatementToRaw(TTtsAbortStatement e) { + e = TTtsAbortStatement(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TTtsBeginStatement` to a raw DB element, if possible. + */ + Raw::Element convertTtsBeginStatementToRaw(TTtsBeginStatement e) { + e = TTtsBeginStatement(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TTtsEndStatement` to a raw DB element, if possible. + */ + Raw::Element convertTtsEndStatementToRaw(TTtsEndStatement e) { e = TTtsEndStatement(result) } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TUnaryMinusExpression` to a raw DB element, if possible. + */ + Raw::Element convertUnaryMinusExpressionToRaw(TUnaryMinusExpression e) { + e = TUnaryMinusExpression(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TUncheckedStatement` to a raw DB element, if possible. + */ + Raw::Element convertUncheckedStatementToRaw(TUncheckedStatement e) { + e = TUncheckedStatement(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TUnspecifiedElement` to a raw DB element, if possible. + */ + Raw::Element convertUnspecifiedElementToRaw(TUnspecifiedElement e) { + e = TUnspecifiedElement(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TUpdateStatement` to a raw DB element, if possible. + */ + Raw::Element convertUpdateStatementToRaw(TUpdateStatement e) { e = TUpdateStatement(result) } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TUsingStatement` to a raw DB element, if possible. + */ + Raw::Element convertUsingStatementToRaw(TUsingStatement e) { e = TUsingStatement(result) } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TValidTimeStateDate` to a raw DB element, if possible. + */ + Raw::Element convertValidTimeStateDateToRaw(TValidTimeStateDate e) { + e = TValidTimeStateDate(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TValidTimeStateRange` to a raw DB element, if possible. + */ + Raw::Element convertValidTimeStateRangeToRaw(TValidTimeStateRange e) { + e = TValidTimeStateRange(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TVarType` to a raw DB element, if possible. + */ + Raw::Element convertVarTypeToRaw(TVarType e) { e = TVarType(result) } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TVariableDeclarationInternal` to a raw DB element, if possible. + */ + Raw::Element convertVariableDeclarationInternalToRaw(TVariableDeclarationInternal e) { + e = TVariableDeclarationInternal(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TVoidType` to a raw DB element, if possible. + */ + Raw::Element convertVoidTypeToRaw(TVoidType e) { e = TVoidType(result) } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TWhileStatement` to a raw DB element, if possible. + */ + Raw::Element convertWhileStatementToRaw(TWhileStatement e) { e = TWhileStatement(result) } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TXppTypeCompilationUnit` to a raw DB element, if possible. + */ + Raw::Element convertXppTypeCompilationUnitToRaw(TXppTypeCompilationUnit e) { + e = TXppTypeCompilationUnit(result) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TAggregateSelection` to a raw DB element, if possible. + */ + Raw::Element convertAggregateSelectionToRaw(TAggregateSelection e) { + result = convertAvgAggregateSelectionToRaw(e) + or + result = convertCountAggregateSelectionToRaw(e) + or + result = convertMaxAggregateSelectionToRaw(e) + or + result = convertMinAggregateSelectionToRaw(e) + or + result = convertSumAggregateSelectionToRaw(e) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TAssignmentBinary` to a raw DB element, if possible. + */ + Raw::Element convertAssignmentBinaryToRaw(TAssignmentBinary e) { + result = convertAssignDecrementStatementToRaw(e) + or + result = convertAssignDivideStatementToRaw(e) + or + result = convertAssignEqualStatementToRaw(e) + or + result = convertAssignIncrementStatementToRaw(e) + or + result = convertAssignMultiplyStatementToRaw(e) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TAssignmentEventHandlerBase` to a raw DB element, if possible. + */ + Raw::Element convertAssignmentEventHandlerBaseToRaw(TAssignmentEventHandlerBase e) { + result = convertAssignmentEventHandlerInstanceToRaw(e) + or + result = convertAssignmentEventHandlerStaticToRaw(e) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TAssignmentEventHandlerStatic` to a raw DB element, if possible. + */ + Raw::Element convertAssignmentEventHandlerStaticToRaw(TAssignmentEventHandlerStatic e) { + result = convertAssignmentEventHandlerClrToRaw(e) + or + result = convertAssignmentEventHandlerStaticInternalToRaw(e) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TAssignmentSingleField` to a raw DB element, if possible. + */ + Raw::Element convertAssignmentSingleFieldToRaw(TAssignmentSingleField e) { + result = convertAssignPostDecrementStatementToRaw(e) + or + result = convertAssignPostIncrementStatementToRaw(e) + or + result = convertAssignPreDecrementStatementToRaw(e) + or + result = convertAssignPreIncrementStatementToRaw(e) + or + result = convertAssignmentBinaryToRaw(e) + or + result = convertAssignmentEventHandlerBaseToRaw(e) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TAssignmentStatement` to a raw DB element, if possible. + */ + Raw::Element convertAssignmentStatementToRaw(TAssignmentStatement e) { + result = convertAssignMultipleFieldStatementToRaw(e) + or + result = convertAssignmentSingleFieldToRaw(e) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TAst` to a raw DB element, if possible. + */ + Raw::Element convertAstToRaw(TAst e) { + result = convertArraySpecificationToRaw(e) + or + result = convertAttributeToRaw(e) + or + result = convertAttributeExpressionToRaw(e) + or + result = convertAttributeListToRaw(e) + or + result = convertAttributeLiteralToRaw(e) + or + result = convertCaseToRaw(e) + or + result = convertCatchToRaw(e) + or + result = convertClassAccessModifierToRaw(e) + or + result = convertCompilationUnitToRaw(e) + or + result = convertCrossCompanyToRaw(e) + or + result = convertExpressionToRaw(e) + or + result = convertFieldAssignmentToRaw(e) + or + result = convertFieldSpecificationToRaw(e) + or + result = convertForAssignToRaw(e) + or + result = convertInsertFieldSpecificationToRaw(e) + or + result = convertInstanceNameToRaw(e) + or + result = convertJoinSpecificationToRaw(e) + or + result = convertModifierToRaw(e) + or + result = convertOrderElementToRaw(e) + or + result = convertQualifierToRaw(e) + or + result = convertQueryToRaw(e) + or + result = convertQueryDataSourceToRaw(e) + or + result = convertQueryDataSourceHavingToRaw(e) + or + result = convertQueryDataSourceRangeToRaw(e) + or + result = convertQueryDataSourceRelationToRaw(e) + or + result = convertSelectionToRaw(e) + or + result = convertSelectionFieldToRaw(e) + or + result = convertStatementToRaw(e) + or + result = convertSwitchCaseToRaw(e) + or + result = convertTableFieldReferenceToRaw(e) + or + result = convertValidTimeStateToRaw(e) + or + result = convertXppTypeToRaw(e) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TAttributeLiteral` to a raw DB element, if possible. + */ + Raw::Element convertAttributeLiteralToRaw(TAttributeLiteral e) { + result = convertContainerAttributeLiteralToRaw(e) + or + result = convertDefaultTypeAttributeLiteralToRaw(e) + or + result = convertEnumAttributeLiteralToRaw(e) + or + result = convertIntrinsicAttributeLiteralToRaw(e) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TBinaryExpression` to a raw DB element, if possible. + */ + Raw::Element convertBinaryExpressionToRaw(TBinaryExpression e) { + result = convertAddExpressionToRaw(e) + or + result = convertAndExpressionToRaw(e) + or + result = convertDivideExpressionToRaw(e) + or + result = convertInExpressionToRaw(e) + or + result = convertIntegerDivideExpressionToRaw(e) + or + result = convertModExpressionToRaw(e) + or + result = convertMultiplyExpressionToRaw(e) + or + result = convertOrExpressionToRaw(e) + or + result = convertPhysicalAndExpressionToRaw(e) + or + result = convertPhysicalOrExpressionToRaw(e) + or + result = convertPhysicalXorExpressionToRaw(e) + or + result = convertRelationalExpressionToRaw(e) + or + result = convertShiftLeftExpressionToRaw(e) + or + result = convertShiftRightExpressionToRaw(e) + or + result = convertSubtractExpressionToRaw(e) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TCase` to a raw DB element, if possible. + */ + Raw::Element convertCaseToRaw(TCase e) { + result = convertCaseDefaultToRaw(e) + or + result = convertCaseValuesToRaw(e) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TCatch` to a raw DB element, if possible. + */ + Raw::Element convertCatchToRaw(TCatch e) { + result = convertCatchAllValuesToRaw(e) + or + result = convertCatchExpressionToRaw(e) + or + result = convertCatchUpdateConflictToRaw(e) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TChangeStatement` to a raw DB element, if possible. + */ + Raw::Element convertChangeStatementToRaw(TChangeStatement e) { + result = convertChangeCompanyStatementToRaw(e) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TClassOrInterface` to a raw DB element, if possible. + */ + Raw::Element convertClassOrInterfaceToRaw(TClassOrInterface e) { + result = convertClassToRaw(e) + or + result = convertInterfaceToRaw(e) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TCompilationUnit` to a raw DB element, if possible. + */ + Raw::Element convertCompilationUnitToRaw(TCompilationUnit e) { + result = convertDeclarationToRaw(e) + or + result = convertExpressionCompilationUnitToRaw(e) + or + result = convertMethodOrDelegateToRaw(e) + or + result = convertModelElementToRaw(e) + or + result = convertXppTypeCompilationUnitToRaw(e) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TCrossCompany` to a raw DB element, if possible. + */ + Raw::Element convertCrossCompanyToRaw(TCrossCompany e) { + result = convertCrossCompanyAllToRaw(e) + or + result = convertCrossCompanyContainerToRaw(e) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TDeclaration` to a raw DB element, if possible. + */ + Raw::Element convertDeclarationToRaw(TDeclaration e) { + result = convertFieldDeclarationToRaw(e) + or + result = convertLocalDeclarationToRaw(e) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TDefaultTypeAttributeLiteral` to a raw DB element, if possible. + */ + Raw::Element convertDefaultTypeAttributeLiteralToRaw(TDefaultTypeAttributeLiteral e) { + result = convertBooleanAttributeLiteralToRaw(e) + or + result = convertDateAttributeLiteralToRaw(e) + or + result = convertDateTimeAttributeLiteralToRaw(e) + or + result = convertDblAttributeLiteralToRaw(e) + or + result = convertGuidAttributeLiteralToRaw(e) + or + result = convertInt64AttributeLiteralToRaw(e) + or + result = convertIntAttributeLiteralToRaw(e) + or + result = convertStringAttributeLiteralToRaw(e) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TDefaultTypeLiteralExpression` to a raw DB element, if possible. + */ + Raw::Element convertDefaultTypeLiteralExpressionToRaw(TDefaultTypeLiteralExpression e) { + result = convertBooleanLiteralExpressionToRaw(e) + or + result = convertDateLiteralExpressionToRaw(e) + or + result = convertDateTimeLiteralExpressionToRaw(e) + or + result = convertInt64LiteralExpressionToRaw(e) + or + result = convertIntLiteralExpressionToRaw(e) + or + result = convertRealLiteralExpressionToRaw(e) + or + result = convertStringLiteralExpressionToRaw(e) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TElement` to a raw DB element, if possible. + */ + Raw::Element convertElementToRaw(TElement e) { + result = convertFileToRaw(e) + or + result = convertLocatableToRaw(e) + or + result = convertLocationToRaw(e) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TErrorElement` to a raw DB element, if possible. + */ + Raw::Element convertErrorElementToRaw(TErrorElement e) { + result = convertUnspecifiedElementToRaw(e) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TEvaluation` to a raw DB element, if possible. + */ + Raw::Element convertEvaluationToRaw(TEvaluation e) { + result = convertGenericEvaluationToRaw(e) + or + result = convertNewCallToRaw(e) + or + result = convertNextExpressionToRaw(e) + or + result = convertProvidedTypeStaticCallToRaw(e) + or + result = convertSuperCallToRaw(e) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TExpression` to a raw DB element, if possible. + */ + Raw::Element convertExpressionToRaw(TExpression e) { + result = convertBinaryExpressionToRaw(e) + or + result = convertConditionalExpressionToRaw(e) + or + result = convertEmptyExpressionToRaw(e) + or + result = convertEvaluationToRaw(e) + or + result = convertFieldExpressionToRaw(e) + or + result = convertIntrinsicToRaw(e) + or + result = convertIsAsExpressionToRaw(e) + or + result = convertLiteralExpressionToRaw(e) + or + result = convertNewClrArrayExpressionToRaw(e) + or + result = convertPlaceholderToRaw(e) + or + result = convertTableLookupExpressionToRaw(e) + or + result = convertUnaryExpressionToRaw(e) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TFieldDeclaration` to a raw DB element, if possible. + */ + Raw::Element convertFieldDeclarationToRaw(TFieldDeclaration e) { + result = convertFieldDeclarationInternalToRaw(e) + or + result = convertTableFieldDeclarationToRaw(e) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TFieldExpression` to a raw DB element, if possible. + */ + Raw::Element convertFieldExpressionToRaw(TFieldExpression e) { + result = convertFieldExpressionInternalToRaw(e) + or + result = convertQualifiedStaticFieldExpressionToRaw(e) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TFieldSpecification` to a raw DB element, if possible. + */ + Raw::Element convertFieldSpecificationToRaw(TFieldSpecification e) { + result = convertQualifiedFieldToRaw(e) + or + result = convertQualifiedNumberedFieldToRaw(e) + or + result = convertQualifiedStaticFieldToRaw(e) + or + result = convertSimpleFieldToRaw(e) + or + result = convertStaticFieldToRaw(e) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TForAssign` to a raw DB element, if possible. + */ + Raw::Element convertForAssignToRaw(TForAssign e) { + result = convertForDeclarationAssignToRaw(e) + or + result = convertForExpressionAssignToRaw(e) + or + result = convertForFieldPostDecrementToRaw(e) + or + result = convertForFieldPostIncrementToRaw(e) + or + result = convertForFieldPreDecrementToRaw(e) + or + result = convertForFieldPreIncrementToRaw(e) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TForExpressionAssign` to a raw DB element, if possible. + */ + Raw::Element convertForExpressionAssignToRaw(TForExpressionAssign e) { + result = convertForFieldAssignToRaw(e) + or + result = convertForFieldDecrementAssignToRaw(e) + or + result = convertForFieldIncrementAssignToRaw(e) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TFormNestedElement` to a raw DB element, if possible. + */ + Raw::Element convertFormNestedElementToRaw(TFormNestedElement e) { + result = convertFormControlToRaw(e) + or + result = convertFormDataFieldToRaw(e) + or + result = convertFormDataSourceToRaw(e) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TGenericEvaluation` to a raw DB element, if possible. + */ + Raw::Element convertGenericEvaluationToRaw(TGenericEvaluation e) { + result = convertFunctionCallToRaw(e) + or + result = convertNewClrCallToRaw(e) + or + result = convertQualifiedCallToRaw(e) + or + result = convertQualifiedStaticCallToRaw(e) + or + result = convertStaticMethodCallToRaw(e) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TGenericXppType` to a raw DB element, if possible. + */ + Raw::Element convertGenericXppTypeToRaw(TGenericXppType e) { + result = convertClrTypeToRaw(e) + or + result = convertNamedTypeToRaw(e) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TInstanceName` to a raw DB element, if possible. + */ + Raw::Element convertInstanceNameToRaw(TInstanceName e) { + result = convertQualifiedInstanceNameToRaw(e) + or + result = convertSimpleInstanceNameToRaw(e) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TIsAsExpression` to a raw DB element, if possible. + */ + Raw::Element convertIsAsExpressionToRaw(TIsAsExpression e) { + result = convertAsClrExpressionToRaw(e) + or + result = convertAsExpressionToRaw(e) + or + result = convertIsClrExpressionToRaw(e) + or + result = convertIsExpressionToRaw(e) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TLiteralExpression` to a raw DB element, if possible. + */ + Raw::Element convertLiteralExpressionToRaw(TLiteralExpression e) { + result = convertClrEnumerationLiteralExpressionToRaw(e) + or + result = convertContainerLiteralExpressionToRaw(e) + or + result = convertDefaultTypeLiteralExpressionToRaw(e) + or + result = convertEnumerationLiteralExpressionToRaw(e) + or + result = convertNullLiteralExpressionToRaw(e) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TLocalDeclaration` to a raw DB element, if possible. + */ + Raw::Element convertLocalDeclarationToRaw(TLocalDeclaration e) { + result = convertFunctionDeclarationToRaw(e) + or + result = convertVariableDeclarationToRaw(e) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TLocatable` to a raw DB element, if possible. + */ + Raw::Element convertLocatableToRaw(TLocatable e) { + result = convertAstToRaw(e) + or + result = convertCommentToRaw(e) + or + result = convertErrorElementToRaw(e) + or + result = convertXppTupleToRaw(e) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TMethodOrDelegate` to a raw DB element, if possible. + */ + Raw::Element convertMethodOrDelegateToRaw(TMethodOrDelegate e) { + result = convertDelegateToRaw(e) + or + result = convertMethodToRaw(e) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TModelElement` to a raw DB element, if possible. + */ + Raw::Element convertModelElementToRaw(TModelElement e) { + result = convertClassOrInterfaceToRaw(e) + or + result = convertFormModelElementToRaw(e) + or + result = convertFormNestedElementToRaw(e) + or + result = convertQueryModelElementToRaw(e) + or + result = convertTableToRaw(e) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TNamedType` to a raw DB element, if possible. + */ + Raw::Element convertNamedTypeToRaw(TNamedType e) { + result = convertFormElementTypeToRaw(e) + or + result = convertNamedTypeInternalToRaw(e) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TOrderElement` to a raw DB element, if possible. + */ + Raw::Element convertOrderElementToRaw(TOrderElement e) { + result = convertGlobalOrderElementToRaw(e) + or + result = convertSimpleOrderElementToRaw(e) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TQualifier` to a raw DB element, if possible. + */ + Raw::Element convertQualifierToRaw(TQualifier e) { + result = convertExpressionQualifierToRaw(e) + or + result = convertSimpleQualifierToRaw(e) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TRelationalExpression` to a raw DB element, if possible. + */ + Raw::Element convertRelationalExpressionToRaw(TRelationalExpression e) { + result = convertEqualExpressionToRaw(e) + or + result = convertGreaterThanExpressionToRaw(e) + or + result = convertGreaterThanOrEqualExpressionToRaw(e) + or + result = convertLessThanExpressionToRaw(e) + or + result = convertLessThanOrEqualExpressionToRaw(e) + or + result = convertLikeExpressionToRaw(e) + or + result = convertNotEqualExpressionToRaw(e) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TSelection` to a raw DB element, if possible. + */ + Raw::Element convertSelectionToRaw(TSelection e) { + result = convertAllFieldsSelectionToRaw(e) + or + result = convertExplicitSelectionToRaw(e) + or + result = convertImplicitSelectionToRaw(e) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TSelectionField` to a raw DB element, if possible. + */ + Raw::Element convertSelectionFieldToRaw(TSelectionField e) { + result = convertAggregateSelectionToRaw(e) + or + result = convertFieldSelectionToRaw(e) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TSimpleQualifier` to a raw DB element, if possible. + */ + Raw::Element convertSimpleQualifierToRaw(TSimpleQualifier e) { + result = convertSimpleQualifierInternalToRaw(e) + or + result = convertStaticQualifierToRaw(e) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TStatement` to a raw DB element, if possible. + */ + Raw::Element convertStatementToRaw(TStatement e) { + result = convertAssignmentStatementToRaw(e) + or + result = convertBreakStatementToRaw(e) + or + result = convertBreakpointStatementToRaw(e) + or + result = convertChangeStatementToRaw(e) + or + result = convertCompoundStatementToRaw(e) + or + result = convertContinueStatementToRaw(e) + or + result = convertDeleteStatementToRaw(e) + or + result = convertDoWhileStatementToRaw(e) + or + result = convertEmptyStatementToRaw(e) + or + result = convertExpressionStatementToRaw(e) + or + result = convertFindStatementToRaw(e) + or + result = convertFlushStatementToRaw(e) + or + result = convertForStatementToRaw(e) + or + result = convertIfStatementToRaw(e) + or + result = convertIfThenElseStatementToRaw(e) + or + result = convertInsertStatementToRaw(e) + or + result = convertLocalDeclarationsStatementToRaw(e) + or + result = convertMoveCursorStatementToRaw(e) + or + result = convertPrintStatementToRaw(e) + or + result = convertRetryStatementToRaw(e) + or + result = convertReturnStatementToRaw(e) + or + result = convertSearchStatementToRaw(e) + or + result = convertSwitchStatementToRaw(e) + or + result = convertThrowStatementToRaw(e) + or + result = convertTryStatementToRaw(e) + or + result = convertTtsStatementToRaw(e) + or + result = convertUncheckedStatementToRaw(e) + or + result = convertUpdateStatementToRaw(e) + or + result = convertUsingStatementToRaw(e) + or + result = convertWhileStatementToRaw(e) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TStringType` to a raw DB element, if possible. + */ + Raw::Element convertStringTypeToRaw(TStringType e) { + result = convertStringLengthTypeToRaw(e) + or + result = convertStringTypeInternalToRaw(e) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TTableFieldReference` to a raw DB element, if possible. + */ + Raw::Element convertTableFieldReferenceToRaw(TTableFieldReference e) { + result = convertNamedFieldReferenceToRaw(e) + or + result = convertNumberedFieldReferenceToRaw(e) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TTtsStatement` to a raw DB element, if possible. + */ + Raw::Element convertTtsStatementToRaw(TTtsStatement e) { + result = convertTtsAbortStatementToRaw(e) + or + result = convertTtsBeginStatementToRaw(e) + or + result = convertTtsEndStatementToRaw(e) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TUnaryExpression` to a raw DB element, if possible. + */ + Raw::Element convertUnaryExpressionToRaw(TUnaryExpression e) { + result = convertNotExpressionToRaw(e) + or + result = convertPhysicalNotExpressionToRaw(e) + or + result = convertUnaryMinusExpressionToRaw(e) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TValidTimeState` to a raw DB element, if possible. + */ + Raw::Element convertValidTimeStateToRaw(TValidTimeState e) { + result = convertValidTimeStateDateToRaw(e) + or + result = convertValidTimeStateRangeToRaw(e) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TVariableDeclaration` to a raw DB element, if possible. + */ + Raw::Element convertVariableDeclarationToRaw(TVariableDeclaration e) { + result = convertParameterDeclarationToRaw(e) + or + result = convertVariableDeclarationInternalToRaw(e) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TXppTuple` to a raw DB element, if possible. + */ + Raw::Element convertXppTupleToRaw(TXppTuple e) { + result = convertAttributeNamedParameterEntryToRaw(e) + or + result = convertCompilationUnitRegionEntryToRaw(e) + or + result = convertEvaluationActualParameterEntryToRaw(e) + or + result = convertModelElementUsingEntryToRaw(e) + or + result = convertSwitchStatementCaseEntryToRaw(e) + or + result = convertTryStatementCatchEntryToRaw(e) + } + + /** + * INTERNAL: Do not use. + * Converts a synthesized `TXppType` to a raw DB element, if possible. + */ + Raw::Element convertXppTypeToRaw(TXppType e) { + result = convertAnyTypeToRaw(e) + or + result = convertBooleanTypeToRaw(e) + or + result = convertContainerTypeToRaw(e) + or + result = convertDateTimeTypeToRaw(e) + or + result = convertDateTypeToRaw(e) + or + result = convertDblTypeToRaw(e) + or + result = convertEnumerationTypeToRaw(e) + or + result = convertGenericXppTypeToRaw(e) + or + result = convertGuidTypeToRaw(e) + or + result = convertInt64TypeToRaw(e) + or + result = convertIntTypeToRaw(e) + or + result = convertProvidedTypeToRaw(e) + or + result = convertStringTypeToRaw(e) + or + result = convertVarTypeToRaw(e) + or + result = convertVoidTypeToRaw(e) + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/SynthConstructors.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/SynthConstructors.qll new file mode 100644 index 000000000000..7e3af170eb1a --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/SynthConstructors.qll @@ -0,0 +1,216 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module exports all modules providing `Element` subclasses. + */ + +import codeql.xpp.elements.internal.AddExpressionConstructor +import codeql.xpp.elements.internal.AllFieldsSelectionConstructor +import codeql.xpp.elements.internal.AndExpressionConstructor +import codeql.xpp.elements.internal.AnyTypeConstructor +import codeql.xpp.elements.internal.ArraySpecificationConstructor +import codeql.xpp.elements.internal.AsClrExpressionConstructor +import codeql.xpp.elements.internal.AsExpressionConstructor +import codeql.xpp.elements.internal.AssignDecrementStatementConstructor +import codeql.xpp.elements.internal.AssignDivideStatementConstructor +import codeql.xpp.elements.internal.AssignEqualStatementConstructor +import codeql.xpp.elements.internal.AssignIncrementStatementConstructor +import codeql.xpp.elements.internal.AssignMultipleFieldStatementConstructor +import codeql.xpp.elements.internal.AssignMultiplyStatementConstructor +import codeql.xpp.elements.internal.AssignPostDecrementStatementConstructor +import codeql.xpp.elements.internal.AssignPostIncrementStatementConstructor +import codeql.xpp.elements.internal.AssignPreDecrementStatementConstructor +import codeql.xpp.elements.internal.AssignPreIncrementStatementConstructor +import codeql.xpp.elements.internal.AssignmentEventHandlerClrConstructor +import codeql.xpp.elements.internal.AssignmentEventHandlerInstanceConstructor +import codeql.xpp.elements.internal.AssignmentEventHandlerStaticInternalConstructor +import codeql.xpp.elements.internal.AttributeConstructor +import codeql.xpp.elements.internal.AttributeExpressionConstructor +import codeql.xpp.elements.internal.AttributeListConstructor +import codeql.xpp.elements.internal.AttributeNamedParameterEntryConstructor +import codeql.xpp.elements.internal.AvgAggregateSelectionConstructor +import codeql.xpp.elements.internal.BooleanAttributeLiteralConstructor +import codeql.xpp.elements.internal.BooleanLiteralExpressionConstructor +import codeql.xpp.elements.internal.BooleanTypeConstructor +import codeql.xpp.elements.internal.BreakStatementConstructor +import codeql.xpp.elements.internal.BreakpointStatementConstructor +import codeql.xpp.elements.internal.CaseDefaultConstructor +import codeql.xpp.elements.internal.CaseValuesConstructor +import codeql.xpp.elements.internal.CatchAllValuesConstructor +import codeql.xpp.elements.internal.CatchExpressionConstructor +import codeql.xpp.elements.internal.CatchUpdateConflictConstructor +import codeql.xpp.elements.internal.ChangeCompanyStatementConstructor +import codeql.xpp.elements.internal.ClassConstructor +import codeql.xpp.elements.internal.ClassAccessModifierConstructor +import codeql.xpp.elements.internal.ClrEnumerationLiteralExpressionConstructor +import codeql.xpp.elements.internal.ClrTypeConstructor +import codeql.xpp.elements.internal.CommentConstructor +import codeql.xpp.elements.internal.CompilationUnitRegionEntryConstructor +import codeql.xpp.elements.internal.CompoundStatementConstructor +import codeql.xpp.elements.internal.ConditionalExpressionConstructor +import codeql.xpp.elements.internal.ContainerAttributeLiteralConstructor +import codeql.xpp.elements.internal.ContainerLiteralExpressionConstructor +import codeql.xpp.elements.internal.ContainerTypeConstructor +import codeql.xpp.elements.internal.ContinueStatementConstructor +import codeql.xpp.elements.internal.CountAggregateSelectionConstructor +import codeql.xpp.elements.internal.CrossCompanyAllConstructor +import codeql.xpp.elements.internal.CrossCompanyContainerConstructor +import codeql.xpp.elements.internal.DateAttributeLiteralConstructor +import codeql.xpp.elements.internal.DateLiteralExpressionConstructor +import codeql.xpp.elements.internal.DateTimeAttributeLiteralConstructor +import codeql.xpp.elements.internal.DateTimeLiteralExpressionConstructor +import codeql.xpp.elements.internal.DateTimeTypeConstructor +import codeql.xpp.elements.internal.DateTypeConstructor +import codeql.xpp.elements.internal.DblAttributeLiteralConstructor +import codeql.xpp.elements.internal.DblTypeConstructor +import codeql.xpp.elements.internal.DelegateConstructor +import codeql.xpp.elements.internal.DeleteStatementConstructor +import codeql.xpp.elements.internal.DivideExpressionConstructor +import codeql.xpp.elements.internal.DoWhileStatementConstructor +import codeql.xpp.elements.internal.EmptyExpressionConstructor +import codeql.xpp.elements.internal.EmptyStatementConstructor +import codeql.xpp.elements.internal.EnumAttributeLiteralConstructor +import codeql.xpp.elements.internal.EnumerationLiteralExpressionConstructor +import codeql.xpp.elements.internal.EnumerationTypeConstructor +import codeql.xpp.elements.internal.EqualExpressionConstructor +import codeql.xpp.elements.internal.EvaluationActualParameterEntryConstructor +import codeql.xpp.elements.internal.ExplicitSelectionConstructor +import codeql.xpp.elements.internal.ExpressionCompilationUnitConstructor +import codeql.xpp.elements.internal.ExpressionQualifierConstructor +import codeql.xpp.elements.internal.ExpressionStatementConstructor +import codeql.xpp.elements.internal.FieldAssignmentConstructor +import codeql.xpp.elements.internal.FieldDeclarationInternalConstructor +import codeql.xpp.elements.internal.FieldExpressionInternalConstructor +import codeql.xpp.elements.internal.FieldSelectionConstructor +import codeql.xpp.elements.internal.FileConstructor +import codeql.xpp.elements.internal.FindStatementConstructor +import codeql.xpp.elements.internal.FlushStatementConstructor +import codeql.xpp.elements.internal.ForDeclarationAssignConstructor +import codeql.xpp.elements.internal.ForFieldAssignConstructor +import codeql.xpp.elements.internal.ForFieldDecrementAssignConstructor +import codeql.xpp.elements.internal.ForFieldIncrementAssignConstructor +import codeql.xpp.elements.internal.ForFieldPostDecrementConstructor +import codeql.xpp.elements.internal.ForFieldPostIncrementConstructor +import codeql.xpp.elements.internal.ForFieldPreDecrementConstructor +import codeql.xpp.elements.internal.ForFieldPreIncrementConstructor +import codeql.xpp.elements.internal.ForStatementConstructor +import codeql.xpp.elements.internal.FormControlConstructor +import codeql.xpp.elements.internal.FormDataFieldConstructor +import codeql.xpp.elements.internal.FormDataSourceConstructor +import codeql.xpp.elements.internal.FormElementTypeConstructor +import codeql.xpp.elements.internal.FormModelElementConstructor +import codeql.xpp.elements.internal.FunctionCallConstructor +import codeql.xpp.elements.internal.FunctionDeclarationConstructor +import codeql.xpp.elements.internal.GlobalOrderElementConstructor +import codeql.xpp.elements.internal.GreaterThanExpressionConstructor +import codeql.xpp.elements.internal.GreaterThanOrEqualExpressionConstructor +import codeql.xpp.elements.internal.GuidAttributeLiteralConstructor +import codeql.xpp.elements.internal.GuidTypeConstructor +import codeql.xpp.elements.internal.IfStatementConstructor +import codeql.xpp.elements.internal.IfThenElseStatementConstructor +import codeql.xpp.elements.internal.ImplicitSelectionConstructor +import codeql.xpp.elements.internal.InExpressionConstructor +import codeql.xpp.elements.internal.InsertFieldSpecificationConstructor +import codeql.xpp.elements.internal.InsertStatementConstructor +import codeql.xpp.elements.internal.Int64AttributeLiteralConstructor +import codeql.xpp.elements.internal.Int64LiteralExpressionConstructor +import codeql.xpp.elements.internal.Int64TypeConstructor +import codeql.xpp.elements.internal.IntAttributeLiteralConstructor +import codeql.xpp.elements.internal.IntLiteralExpressionConstructor +import codeql.xpp.elements.internal.IntTypeConstructor +import codeql.xpp.elements.internal.IntegerDivideExpressionConstructor +import codeql.xpp.elements.internal.InterfaceConstructor +import codeql.xpp.elements.internal.IntrinsicConstructor +import codeql.xpp.elements.internal.IntrinsicAttributeLiteralConstructor +import codeql.xpp.elements.internal.IsClrExpressionConstructor +import codeql.xpp.elements.internal.IsExpressionConstructor +import codeql.xpp.elements.internal.JoinSpecificationConstructor +import codeql.xpp.elements.internal.LessThanExpressionConstructor +import codeql.xpp.elements.internal.LessThanOrEqualExpressionConstructor +import codeql.xpp.elements.internal.LikeExpressionConstructor +import codeql.xpp.elements.internal.LocalDeclarationsStatementConstructor +import codeql.xpp.elements.internal.LocationConstructor +import codeql.xpp.elements.internal.MaxAggregateSelectionConstructor +import codeql.xpp.elements.internal.MethodConstructor +import codeql.xpp.elements.internal.MinAggregateSelectionConstructor +import codeql.xpp.elements.internal.ModExpressionConstructor +import codeql.xpp.elements.internal.ModelElementUsingEntryConstructor +import codeql.xpp.elements.internal.ModifierConstructor +import codeql.xpp.elements.internal.MoveCursorStatementConstructor +import codeql.xpp.elements.internal.MultiplyExpressionConstructor +import codeql.xpp.elements.internal.NamedFieldReferenceConstructor +import codeql.xpp.elements.internal.NamedTypeInternalConstructor +import codeql.xpp.elements.internal.NewCallConstructor +import codeql.xpp.elements.internal.NewClrArrayExpressionConstructor +import codeql.xpp.elements.internal.NewClrCallConstructor +import codeql.xpp.elements.internal.NextExpressionConstructor +import codeql.xpp.elements.internal.NotEqualExpressionConstructor +import codeql.xpp.elements.internal.NotExpressionConstructor +import codeql.xpp.elements.internal.NullLiteralExpressionConstructor +import codeql.xpp.elements.internal.NumberedFieldReferenceConstructor +import codeql.xpp.elements.internal.OrExpressionConstructor +import codeql.xpp.elements.internal.ParameterDeclarationConstructor +import codeql.xpp.elements.internal.PhysicalAndExpressionConstructor +import codeql.xpp.elements.internal.PhysicalNotExpressionConstructor +import codeql.xpp.elements.internal.PhysicalOrExpressionConstructor +import codeql.xpp.elements.internal.PhysicalXorExpressionConstructor +import codeql.xpp.elements.internal.PlaceholderConstructor +import codeql.xpp.elements.internal.PrintStatementConstructor +import codeql.xpp.elements.internal.ProvidedTypeConstructor +import codeql.xpp.elements.internal.ProvidedTypeStaticCallConstructor +import codeql.xpp.elements.internal.QualifiedCallConstructor +import codeql.xpp.elements.internal.QualifiedFieldConstructor +import codeql.xpp.elements.internal.QualifiedInstanceNameConstructor +import codeql.xpp.elements.internal.QualifiedNumberedFieldConstructor +import codeql.xpp.elements.internal.QualifiedStaticCallConstructor +import codeql.xpp.elements.internal.QualifiedStaticFieldConstructor +import codeql.xpp.elements.internal.QualifiedStaticFieldExpressionConstructor +import codeql.xpp.elements.internal.QueryConstructor +import codeql.xpp.elements.internal.QueryDataSourceConstructor +import codeql.xpp.elements.internal.QueryDataSourceHavingConstructor +import codeql.xpp.elements.internal.QueryDataSourceRangeConstructor +import codeql.xpp.elements.internal.QueryDataSourceRelationConstructor +import codeql.xpp.elements.internal.QueryModelElementConstructor +import codeql.xpp.elements.internal.RealLiteralExpressionConstructor +import codeql.xpp.elements.internal.RetryStatementConstructor +import codeql.xpp.elements.internal.ReturnStatementConstructor +import codeql.xpp.elements.internal.SearchStatementConstructor +import codeql.xpp.elements.internal.ShiftLeftExpressionConstructor +import codeql.xpp.elements.internal.ShiftRightExpressionConstructor +import codeql.xpp.elements.internal.SimpleFieldConstructor +import codeql.xpp.elements.internal.SimpleInstanceNameConstructor +import codeql.xpp.elements.internal.SimpleOrderElementConstructor +import codeql.xpp.elements.internal.SimpleQualifierInternalConstructor +import codeql.xpp.elements.internal.StaticFieldConstructor +import codeql.xpp.elements.internal.StaticMethodCallConstructor +import codeql.xpp.elements.internal.StaticQualifierConstructor +import codeql.xpp.elements.internal.StringAttributeLiteralConstructor +import codeql.xpp.elements.internal.StringLengthTypeConstructor +import codeql.xpp.elements.internal.StringLiteralExpressionConstructor +import codeql.xpp.elements.internal.StringTypeInternalConstructor +import codeql.xpp.elements.internal.SubtractExpressionConstructor +import codeql.xpp.elements.internal.SumAggregateSelectionConstructor +import codeql.xpp.elements.internal.SuperCallConstructor +import codeql.xpp.elements.internal.SwitchCaseConstructor +import codeql.xpp.elements.internal.SwitchStatementConstructor +import codeql.xpp.elements.internal.SwitchStatementCaseEntryConstructor +import codeql.xpp.elements.internal.TableConstructor +import codeql.xpp.elements.internal.TableFieldDeclarationConstructor +import codeql.xpp.elements.internal.TableLookupExpressionConstructor +import codeql.xpp.elements.internal.ThrowStatementConstructor +import codeql.xpp.elements.internal.TryStatementConstructor +import codeql.xpp.elements.internal.TryStatementCatchEntryConstructor +import codeql.xpp.elements.internal.TtsAbortStatementConstructor +import codeql.xpp.elements.internal.TtsBeginStatementConstructor +import codeql.xpp.elements.internal.TtsEndStatementConstructor +import codeql.xpp.elements.internal.UnaryMinusExpressionConstructor +import codeql.xpp.elements.internal.UncheckedStatementConstructor +import codeql.xpp.elements.internal.UnspecifiedElementConstructor +import codeql.xpp.elements.internal.UpdateStatementConstructor +import codeql.xpp.elements.internal.UsingStatementConstructor +import codeql.xpp.elements.internal.ValidTimeStateDateConstructor +import codeql.xpp.elements.internal.ValidTimeStateRangeConstructor +import codeql.xpp.elements.internal.VarTypeConstructor +import codeql.xpp.elements.internal.VariableDeclarationInternalConstructor +import codeql.xpp.elements.internal.VoidTypeConstructor +import codeql.xpp.elements.internal.WhileStatementConstructor +import codeql.xpp.elements.internal.XppTypeCompilationUnitConstructor diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/Table.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/Table.qll new file mode 100644 index 000000000000..889ef6c8dc2e --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/Table.qll @@ -0,0 +1,133 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `Table`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.AttributeList +import codeql.xpp.elements.FieldDeclaration +import codeql.xpp.elements.internal.ModelElementImpl::Impl as ModelElementImpl + +/** + * INTERNAL: This module contains the fully generated definition of `Table` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::Table` class directly. + * Use the subclass `Table`, where the following predicates are available. + */ + class Table extends Synth::TTable, ModelElementImpl::ModelElement { + override string getAPrimaryQlClass() { result = "Table" } + + /** + * Gets the attributes of this table, if it exists. + */ + AttributeList getAttributes() { + result = + Synth::convertAttributeListFromRaw(Synth::convertTableToRaw(this) + .(Raw::Table) + .getAttributes()) + } + + /** + * Holds if `getAttributes()` exists. + */ + final predicate hasAttributes() { exists(this.getAttributes()) } + + /** + * Gets the element type name of this table, if it exists. + */ + string getElementTypeName() { + result = Synth::convertTableToRaw(this).(Raw::Table).getElementTypeName() + } + + /** + * Holds if `getElementTypeName()` exists. + */ + final predicate hasElementTypeName() { exists(this.getElementTypeName()) } + + /** + * Gets the extends of this table, if it exists. + */ + string getExtends() { result = Synth::convertTableToRaw(this).(Raw::Table).getExtends() } + + /** + * Holds if `getExtends()` exists. + */ + final predicate hasExtends() { exists(this.getExtends()) } + + /** + * Gets the `index`th field of this table (0-based). + */ + FieldDeclaration getField(int index) { + result = + Synth::convertFieldDeclarationFromRaw(Synth::convertTableToRaw(this) + .(Raw::Table) + .getField(index)) + } + + /** + * Gets any of the fields of this table. + */ + final FieldDeclaration getAField() { result = this.getField(_) } + + /** + * Gets the number of fields of this table. + */ + final int getNumberOfFields() { result = count(int i | exists(this.getField(i))) } + + /** + * Gets the `index`th index of this table (0-based). + */ + string getIndex(int index) { + result = Synth::convertTableToRaw(this).(Raw::Table).getIndex(index) + } + + /** + * Gets any of the indexes of this table. + */ + final string getAnIndex() { result = this.getIndex(_) } + + /** + * Gets the number of indexes of this table. + */ + final int getNumberOfIndexes() { result = count(int i | exists(this.getIndex(i))) } + + /** + * Holds if this table is aggregate data entity. + */ + predicate isAggregateDataEntity() { + Synth::convertTableToRaw(this).(Raw::Table).isAggregateDataEntity() + } + + /** + * Holds if this table is data entity view. + */ + predicate isDataEntityView() { Synth::convertTableToRaw(this).(Raw::Table).isDataEntityView() } + + /** + * Holds if this table is map. + */ + predicate isMap() { Synth::convertTableToRaw(this).(Raw::Table).isMap() } + + /** + * Holds if this table is updatable. + */ + predicate isUpdatable() { Synth::convertTableToRaw(this).(Raw::Table).isUpdatable() } + + /** + * Holds if this table is view. + */ + predicate isView() { Synth::convertTableToRaw(this).(Raw::Table).isView() } + + /** + * Holds if this table support inheritance. + */ + predicate supportInheritance() { + Synth::convertTableToRaw(this).(Raw::Table).supportInheritance() + } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/TableFieldDeclaration.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/TableFieldDeclaration.qll new file mode 100644 index 000000000000..b03b5667a1d8 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/TableFieldDeclaration.qll @@ -0,0 +1,25 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `TableFieldDeclaration`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.FieldDeclarationImpl::Impl as FieldDeclarationImpl + +/** + * INTERNAL: This module contains the fully generated definition of `TableFieldDeclaration` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::TableFieldDeclaration` class directly. + * Use the subclass `TableFieldDeclaration`, where the following predicates are available. + */ + class TableFieldDeclaration extends Synth::TTableFieldDeclaration, + FieldDeclarationImpl::FieldDeclaration + { + override string getAPrimaryQlClass() { result = "TableFieldDeclaration" } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/TableFieldReference.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/TableFieldReference.qll new file mode 100644 index 000000000000..c2e05b515cc0 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/TableFieldReference.qll @@ -0,0 +1,37 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `TableFieldReference`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.AstImpl::Impl as AstImpl +import codeql.xpp.elements.Expression + +/** + * INTERNAL: This module contains the fully generated definition of `TableFieldReference` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::TableFieldReference` class directly. + * Use the subclass `TableFieldReference`, where the following predicates are available. + */ + class TableFieldReference extends Synth::TTableFieldReference, AstImpl::Ast { + /** + * Gets the index of this table field reference, if it exists. + */ + Expression getIndex() { + result = + Synth::convertExpressionFromRaw(Synth::convertTableFieldReferenceToRaw(this) + .(Raw::TableFieldReference) + .getIndex()) + } + + /** + * Holds if `getIndex()` exists. + */ + final predicate hasIndex() { exists(this.getIndex()) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/TableLookupExpression.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/TableLookupExpression.qll new file mode 100644 index 000000000000..f712aee6bac3 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/TableLookupExpression.qll @@ -0,0 +1,55 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `TableLookupExpression`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.ExpressionImpl::Impl as ExpressionImpl +import codeql.xpp.elements.Query +import codeql.xpp.elements.TableFieldReference + +/** + * INTERNAL: This module contains the fully generated definition of `TableLookupExpression` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::TableLookupExpression` class directly. + * Use the subclass `TableLookupExpression`, where the following predicates are available. + */ + class TableLookupExpression extends Synth::TTableLookupExpression, ExpressionImpl::Expression { + override string getAPrimaryQlClass() { result = "TableLookupExpression" } + + /** + * Gets the field of this table lookup expression, if it exists. + */ + TableFieldReference getField() { + result = + Synth::convertTableFieldReferenceFromRaw(Synth::convertTableLookupExpressionToRaw(this) + .(Raw::TableLookupExpression) + .getField()) + } + + /** + * Holds if `getField()` exists. + */ + final predicate hasField() { exists(this.getField()) } + + /** + * Gets the query of this table lookup expression, if it exists. + */ + Query getQuery() { + result = + Synth::convertQueryFromRaw(Synth::convertTableLookupExpressionToRaw(this) + .(Raw::TableLookupExpression) + .getQuery()) + } + + /** + * Holds if `getQuery()` exists. + */ + final predicate hasQuery() { exists(this.getQuery()) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/ThrowStatement.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/ThrowStatement.qll new file mode 100644 index 000000000000..d6e46b5d5dc2 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/ThrowStatement.qll @@ -0,0 +1,39 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `ThrowStatement`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.Expression +import codeql.xpp.elements.internal.StatementImpl::Impl as StatementImpl + +/** + * INTERNAL: This module contains the fully generated definition of `ThrowStatement` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::ThrowStatement` class directly. + * Use the subclass `ThrowStatement`, where the following predicates are available. + */ + class ThrowStatement extends Synth::TThrowStatement, StatementImpl::Statement { + override string getAPrimaryQlClass() { result = "ThrowStatement" } + + /** + * Gets the exception of this throw statement, if it exists. + */ + Expression getException() { + result = + Synth::convertExpressionFromRaw(Synth::convertThrowStatementToRaw(this) + .(Raw::ThrowStatement) + .getException()) + } + + /** + * Holds if `getException()` exists. + */ + final predicate hasException() { exists(this.getException()) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/TryStatement.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/TryStatement.qll new file mode 100644 index 000000000000..99e1d68585e0 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/TryStatement.qll @@ -0,0 +1,75 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `TryStatement`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.Statement +import codeql.xpp.elements.internal.StatementImpl::Impl as StatementImpl +import codeql.xpp.elements.TryStatementCatchEntry + +/** + * INTERNAL: This module contains the fully generated definition of `TryStatement` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::TryStatement` class directly. + * Use the subclass `TryStatement`, where the following predicates are available. + */ + class TryStatement extends Synth::TTryStatement, StatementImpl::Statement { + override string getAPrimaryQlClass() { result = "TryStatement" } + + /** + * Gets the `index`th catch of this try statement (0-based). + */ + TryStatementCatchEntry getCatch(int index) { + result = + Synth::convertTryStatementCatchEntryFromRaw(Synth::convertTryStatementToRaw(this) + .(Raw::TryStatement) + .getCatch(index)) + } + + /** + * Gets any of the catches of this try statement. + */ + final TryStatementCatchEntry getACatch() { result = this.getCatch(_) } + + /** + * Gets the number of catches of this try statement. + */ + final int getNumberOfCatches() { result = count(int i | exists(this.getCatch(i))) } + + /** + * Gets the finally of this try statement, if it exists. + */ + Statement getFinally() { + result = + Synth::convertStatementFromRaw(Synth::convertTryStatementToRaw(this) + .(Raw::TryStatement) + .getFinally()) + } + + /** + * Holds if `getFinally()` exists. + */ + final predicate hasFinally() { exists(this.getFinally()) } + + /** + * Gets the statement of this try statement, if it exists. + */ + Statement getStatement() { + result = + Synth::convertStatementFromRaw(Synth::convertTryStatementToRaw(this) + .(Raw::TryStatement) + .getStatement()) + } + + /** + * Holds if `getStatement()` exists. + */ + final predicate hasStatement() { exists(this.getStatement()) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/TryStatementCatchEntry.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/TryStatementCatchEntry.qll new file mode 100644 index 000000000000..45c4f27e77b9 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/TryStatementCatchEntry.qll @@ -0,0 +1,55 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `TryStatementCatchEntry`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.Catch +import codeql.xpp.elements.Statement +import codeql.xpp.elements.internal.XppTupleImpl::Impl as XppTupleImpl + +/** + * INTERNAL: This module contains the fully generated definition of `TryStatementCatchEntry` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::TryStatementCatchEntry` class directly. + * Use the subclass `TryStatementCatchEntry`, where the following predicates are available. + */ + class TryStatementCatchEntry extends Synth::TTryStatementCatchEntry, XppTupleImpl::XppTuple { + override string getAPrimaryQlClass() { result = "TryStatementCatchEntry" } + + /** + * Gets the catch of this try statement catch entry, if it exists. + */ + Catch getCatch() { + result = + Synth::convertCatchFromRaw(Synth::convertTryStatementCatchEntryToRaw(this) + .(Raw::TryStatementCatchEntry) + .getCatch()) + } + + /** + * Holds if `getCatch()` exists. + */ + final predicate hasCatch() { exists(this.getCatch()) } + + /** + * Gets the statement of this try statement catch entry, if it exists. + */ + Statement getStatement() { + result = + Synth::convertStatementFromRaw(Synth::convertTryStatementCatchEntryToRaw(this) + .(Raw::TryStatementCatchEntry) + .getStatement()) + } + + /** + * Holds if `getStatement()` exists. + */ + final predicate hasStatement() { exists(this.getStatement()) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/TtsAbortStatement.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/TtsAbortStatement.qll new file mode 100644 index 000000000000..88b833d25e75 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/TtsAbortStatement.qll @@ -0,0 +1,23 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `TtsAbortStatement`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.TtsStatementImpl::Impl as TtsStatementImpl + +/** + * INTERNAL: This module contains the fully generated definition of `TtsAbortStatement` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::TtsAbortStatement` class directly. + * Use the subclass `TtsAbortStatement`, where the following predicates are available. + */ + class TtsAbortStatement extends Synth::TTtsAbortStatement, TtsStatementImpl::TtsStatement { + override string getAPrimaryQlClass() { result = "TtsAbortStatement" } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/TtsBeginStatement.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/TtsBeginStatement.qll new file mode 100644 index 000000000000..633ea1a10481 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/TtsBeginStatement.qll @@ -0,0 +1,23 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `TtsBeginStatement`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.TtsStatementImpl::Impl as TtsStatementImpl + +/** + * INTERNAL: This module contains the fully generated definition of `TtsBeginStatement` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::TtsBeginStatement` class directly. + * Use the subclass `TtsBeginStatement`, where the following predicates are available. + */ + class TtsBeginStatement extends Synth::TTtsBeginStatement, TtsStatementImpl::TtsStatement { + override string getAPrimaryQlClass() { result = "TtsBeginStatement" } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/TtsEndStatement.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/TtsEndStatement.qll new file mode 100644 index 000000000000..fe8cdac99d07 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/TtsEndStatement.qll @@ -0,0 +1,23 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `TtsEndStatement`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.TtsStatementImpl::Impl as TtsStatementImpl + +/** + * INTERNAL: This module contains the fully generated definition of `TtsEndStatement` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::TtsEndStatement` class directly. + * Use the subclass `TtsEndStatement`, where the following predicates are available. + */ + class TtsEndStatement extends Synth::TTtsEndStatement, TtsStatementImpl::TtsStatement { + override string getAPrimaryQlClass() { result = "TtsEndStatement" } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/TtsStatement.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/TtsStatement.qll new file mode 100644 index 000000000000..8ae911efffed --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/TtsStatement.qll @@ -0,0 +1,21 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `TtsStatement`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.StatementImpl::Impl as StatementImpl + +/** + * INTERNAL: This module contains the fully generated definition of `TtsStatement` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::TtsStatement` class directly. + * Use the subclass `TtsStatement`, where the following predicates are available. + */ + class TtsStatement extends Synth::TTtsStatement, StatementImpl::Statement { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/UnaryExpression.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/UnaryExpression.qll new file mode 100644 index 000000000000..7b1a5e177c69 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/UnaryExpression.qll @@ -0,0 +1,37 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `UnaryExpression`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.Expression +import codeql.xpp.elements.internal.ExpressionImpl::Impl as ExpressionImpl + +/** + * INTERNAL: This module contains the fully generated definition of `UnaryExpression` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::UnaryExpression` class directly. + * Use the subclass `UnaryExpression`, where the following predicates are available. + */ + class UnaryExpression extends Synth::TUnaryExpression, ExpressionImpl::Expression { + /** + * Gets the expression of this unary expression, if it exists. + */ + Expression getExpression() { + result = + Synth::convertExpressionFromRaw(Synth::convertUnaryExpressionToRaw(this) + .(Raw::UnaryExpression) + .getExpression()) + } + + /** + * Holds if `getExpression()` exists. + */ + final predicate hasExpression() { exists(this.getExpression()) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/UnaryMinusExpression.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/UnaryMinusExpression.qll new file mode 100644 index 000000000000..77d0ac0aa97b --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/UnaryMinusExpression.qll @@ -0,0 +1,25 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `UnaryMinusExpression`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.UnaryExpressionImpl::Impl as UnaryExpressionImpl + +/** + * INTERNAL: This module contains the fully generated definition of `UnaryMinusExpression` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::UnaryMinusExpression` class directly. + * Use the subclass `UnaryMinusExpression`, where the following predicates are available. + */ + class UnaryMinusExpression extends Synth::TUnaryMinusExpression, + UnaryExpressionImpl::UnaryExpression + { + override string getAPrimaryQlClass() { result = "UnaryMinusExpression" } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/UncheckedStatement.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/UncheckedStatement.qll new file mode 100644 index 000000000000..93113f193fed --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/UncheckedStatement.qll @@ -0,0 +1,55 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `UncheckedStatement`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.Expression +import codeql.xpp.elements.Statement +import codeql.xpp.elements.internal.StatementImpl::Impl as StatementImpl + +/** + * INTERNAL: This module contains the fully generated definition of `UncheckedStatement` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::UncheckedStatement` class directly. + * Use the subclass `UncheckedStatement`, where the following predicates are available. + */ + class UncheckedStatement extends Synth::TUncheckedStatement, StatementImpl::Statement { + override string getAPrimaryQlClass() { result = "UncheckedStatement" } + + /** + * Gets the expression of this unchecked statement, if it exists. + */ + Expression getExpression() { + result = + Synth::convertExpressionFromRaw(Synth::convertUncheckedStatementToRaw(this) + .(Raw::UncheckedStatement) + .getExpression()) + } + + /** + * Holds if `getExpression()` exists. + */ + final predicate hasExpression() { exists(this.getExpression()) } + + /** + * Gets the statement of this unchecked statement, if it exists. + */ + Statement getStatement() { + result = + Synth::convertStatementFromRaw(Synth::convertUncheckedStatementToRaw(this) + .(Raw::UncheckedStatement) + .getStatement()) + } + + /** + * Holds if `getStatement()` exists. + */ + final predicate hasStatement() { exists(this.getStatement()) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/UnspecifiedElement.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/UnspecifiedElement.qll new file mode 100644 index 000000000000..c457ec882a7e --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/UnspecifiedElement.qll @@ -0,0 +1,66 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `UnspecifiedElement`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.Element +import codeql.xpp.elements.internal.ErrorElementImpl::Impl as ErrorElementImpl + +/** + * INTERNAL: This module contains the fully generated definition of `UnspecifiedElement` and should not + * be referenced directly. + */ +module Generated { + /** + * A node that could not be extracted, for example because of a syntax error. + * INTERNAL: Do not reference the `Generated::UnspecifiedElement` class directly. + * Use the subclass `UnspecifiedElement`, where the following predicates are available. + */ + class UnspecifiedElement extends Synth::TUnspecifiedElement, ErrorElementImpl::ErrorElement { + override string getAPrimaryQlClass() { result = "UnspecifiedElement" } + + /** + * Gets the parent of this unspecified element, if it exists. + */ + Element getParent() { + result = + Synth::convertElementFromRaw(Synth::convertUnspecifiedElementToRaw(this) + .(Raw::UnspecifiedElement) + .getParent()) + } + + /** + * Holds if `getParent()` exists. + */ + final predicate hasParent() { exists(this.getParent()) } + + /** + * Gets the property of this unspecified element. + */ + string getProperty() { + result = Synth::convertUnspecifiedElementToRaw(this).(Raw::UnspecifiedElement).getProperty() + } + + /** + * Gets the index of this unspecified element, if it exists. + */ + int getIndex() { + result = Synth::convertUnspecifiedElementToRaw(this).(Raw::UnspecifiedElement).getIndex() + } + + /** + * Holds if `getIndex()` exists. + */ + final predicate hasIndex() { exists(this.getIndex()) } + + /** + * Gets the error of this unspecified element. + */ + string getError() { + result = Synth::convertUnspecifiedElementToRaw(this).(Raw::UnspecifiedElement).getError() + } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/UpdateStatement.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/UpdateStatement.qll new file mode 100644 index 000000000000..536ca3f3e202 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/UpdateStatement.qll @@ -0,0 +1,123 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `UpdateStatement`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.CrossCompany +import codeql.xpp.elements.Expression +import codeql.xpp.elements.FieldAssignment +import codeql.xpp.elements.JoinSpecification +import codeql.xpp.elements.internal.StatementImpl::Impl as StatementImpl + +/** + * INTERNAL: This module contains the fully generated definition of `UpdateStatement` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::UpdateStatement` class directly. + * Use the subclass `UpdateStatement`, where the following predicates are available. + */ + class UpdateStatement extends Synth::TUpdateStatement, StatementImpl::Statement { + override string getAPrimaryQlClass() { result = "UpdateStatement" } + + /** + * Gets the cross company of this update statement, if it exists. + */ + CrossCompany getCrossCompany() { + result = + Synth::convertCrossCompanyFromRaw(Synth::convertUpdateStatementToRaw(this) + .(Raw::UpdateStatement) + .getCrossCompany()) + } + + /** + * Holds if `getCrossCompany()` exists. + */ + final predicate hasCrossCompany() { exists(this.getCrossCompany()) } + + /** + * Gets the `index`th field assignment of this update statement (0-based). + */ + FieldAssignment getFieldAssignment(int index) { + result = + Synth::convertFieldAssignmentFromRaw(Synth::convertUpdateStatementToRaw(this) + .(Raw::UpdateStatement) + .getFieldAssignment(index)) + } + + /** + * Gets any of the field assignments of this update statement. + */ + final FieldAssignment getAFieldAssignment() { result = this.getFieldAssignment(_) } + + /** + * Gets the number of field assignments of this update statement. + */ + final int getNumberOfFieldAssignments() { + result = count(int i | exists(this.getFieldAssignment(i))) + } + + /** + * Gets the `index`th hint of this update statement (0-based). + */ + string getHint(int index) { + result = Synth::convertUpdateStatementToRaw(this).(Raw::UpdateStatement).getHint(index) + } + + /** + * Gets any of the hints of this update statement. + */ + final string getAHint() { result = this.getHint(_) } + + /** + * Gets the number of hints of this update statement. + */ + final int getNumberOfHints() { result = count(int i | exists(this.getHint(i))) } + + /** + * Gets the joins of this update statement, if it exists. + */ + JoinSpecification getJoins() { + result = + Synth::convertJoinSpecificationFromRaw(Synth::convertUpdateStatementToRaw(this) + .(Raw::UpdateStatement) + .getJoins()) + } + + /** + * Holds if `getJoins()` exists. + */ + final predicate hasJoins() { exists(this.getJoins()) } + + /** + * Gets the table of this update statement, if it exists. + */ + string getTable() { + result = Synth::convertUpdateStatementToRaw(this).(Raw::UpdateStatement).getTable() + } + + /** + * Holds if `getTable()` exists. + */ + final predicate hasTable() { exists(this.getTable()) } + + /** + * Gets the where of this update statement, if it exists. + */ + Expression getWhere() { + result = + Synth::convertExpressionFromRaw(Synth::convertUpdateStatementToRaw(this) + .(Raw::UpdateStatement) + .getWhere()) + } + + /** + * Holds if `getWhere()` exists. + */ + final predicate hasWhere() { exists(this.getWhere()) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/UsingStatement.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/UsingStatement.qll new file mode 100644 index 000000000000..b532d079c528 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/UsingStatement.qll @@ -0,0 +1,64 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `UsingStatement`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.Statement +import codeql.xpp.elements.internal.StatementImpl::Impl as StatementImpl +import codeql.xpp.elements.VariableDeclaration + +/** + * INTERNAL: This module contains the fully generated definition of `UsingStatement` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::UsingStatement` class directly. + * Use the subclass `UsingStatement`, where the following predicates are available. + */ + class UsingStatement extends Synth::TUsingStatement, StatementImpl::Statement { + override string getAPrimaryQlClass() { result = "UsingStatement" } + + /** + * Gets the `index`th disposable object initializer of this using statement (0-based). + */ + VariableDeclaration getDisposableObjectInitializer(int index) { + result = + Synth::convertVariableDeclarationFromRaw(Synth::convertUsingStatementToRaw(this) + .(Raw::UsingStatement) + .getDisposableObjectInitializer(index)) + } + + /** + * Gets any of the disposable object initializers of this using statement. + */ + final VariableDeclaration getADisposableObjectInitializer() { + result = this.getDisposableObjectInitializer(_) + } + + /** + * Gets the number of disposable object initializers of this using statement. + */ + final int getNumberOfDisposableObjectInitializers() { + result = count(int i | exists(this.getDisposableObjectInitializer(i))) + } + + /** + * Gets the statement of this using statement, if it exists. + */ + Statement getStatement() { + result = + Synth::convertStatementFromRaw(Synth::convertUsingStatementToRaw(this) + .(Raw::UsingStatement) + .getStatement()) + } + + /** + * Holds if `getStatement()` exists. + */ + final predicate hasStatement() { exists(this.getStatement()) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/ValidTimeState.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/ValidTimeState.qll new file mode 100644 index 000000000000..7b3761e82b81 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/ValidTimeState.qll @@ -0,0 +1,21 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `ValidTimeState`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.AstImpl::Impl as AstImpl + +/** + * INTERNAL: This module contains the fully generated definition of `ValidTimeState` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::ValidTimeState` class directly. + * Use the subclass `ValidTimeState`, where the following predicates are available. + */ + class ValidTimeState extends Synth::TValidTimeState, AstImpl::Ast { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/ValidTimeStateDate.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/ValidTimeStateDate.qll new file mode 100644 index 000000000000..3bba1fe147c6 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/ValidTimeStateDate.qll @@ -0,0 +1,36 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `ValidTimeStateDate`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.ValidTimeStateImpl::Impl as ValidTimeStateImpl + +/** + * INTERNAL: This module contains the fully generated definition of `ValidTimeStateDate` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::ValidTimeStateDate` class directly. + * Use the subclass `ValidTimeStateDate`, where the following predicates are available. + */ + class ValidTimeStateDate extends Synth::TValidTimeStateDate, ValidTimeStateImpl::ValidTimeState { + override string getAPrimaryQlClass() { result = "ValidTimeStateDate" } + + /** + * Gets the date variable of this valid time state date, if it exists. + */ + string getDateVariable() { + result = + Synth::convertValidTimeStateDateToRaw(this).(Raw::ValidTimeStateDate).getDateVariable() + } + + /** + * Holds if `getDateVariable()` exists. + */ + final predicate hasDateVariable() { exists(this.getDateVariable()) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/ValidTimeStateRange.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/ValidTimeStateRange.qll new file mode 100644 index 000000000000..b5ae6b0f5cb3 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/ValidTimeStateRange.qll @@ -0,0 +1,51 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `ValidTimeStateRange`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.ValidTimeStateImpl::Impl as ValidTimeStateImpl + +/** + * INTERNAL: This module contains the fully generated definition of `ValidTimeStateRange` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::ValidTimeStateRange` class directly. + * Use the subclass `ValidTimeStateRange`, where the following predicates are available. + */ + class ValidTimeStateRange extends Synth::TValidTimeStateRange, ValidTimeStateImpl::ValidTimeState { + override string getAPrimaryQlClass() { result = "ValidTimeStateRange" } + + /** + * Gets the from date variable of this valid time state range, if it exists. + */ + string getFromDateVariable() { + result = + Synth::convertValidTimeStateRangeToRaw(this) + .(Raw::ValidTimeStateRange) + .getFromDateVariable() + } + + /** + * Holds if `getFromDateVariable()` exists. + */ + final predicate hasFromDateVariable() { exists(this.getFromDateVariable()) } + + /** + * Gets the to date variable of this valid time state range, if it exists. + */ + string getToDateVariable() { + result = + Synth::convertValidTimeStateRangeToRaw(this).(Raw::ValidTimeStateRange).getToDateVariable() + } + + /** + * Holds if `getToDateVariable()` exists. + */ + final predicate hasToDateVariable() { exists(this.getToDateVariable()) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/VarType.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/VarType.qll new file mode 100644 index 000000000000..da0fdc22cdc9 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/VarType.qll @@ -0,0 +1,23 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `VarType`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.XppTypeImpl::Impl as XppTypeImpl + +/** + * INTERNAL: This module contains the fully generated definition of `VarType` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::VarType` class directly. + * Use the subclass `VarType`, where the following predicates are available. + */ + class VarType extends Synth::TVarType, XppTypeImpl::XppType { + override string getAPrimaryQlClass() { result = "VarType" } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/VariableDeclaration.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/VariableDeclaration.qll new file mode 100644 index 000000000000..279cd838aa2d --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/VariableDeclaration.qll @@ -0,0 +1,59 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `VariableDeclaration`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.Expression +import codeql.xpp.elements.internal.LocalDeclarationImpl::Impl as LocalDeclarationImpl + +/** + * INTERNAL: This module contains the fully generated definition of `VariableDeclaration` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::VariableDeclaration` class directly. + * Use the subclass `VariableDeclaration`, where the following predicates are available. + */ + class VariableDeclaration extends Synth::TVariableDeclaration, + LocalDeclarationImpl::LocalDeclaration + { + /** + * Gets the element type name of this variable declaration, if it exists. + */ + string getElementTypeName() { + result = + Synth::convertVariableDeclarationToRaw(this).(Raw::VariableDeclaration).getElementTypeName() + } + + /** + * Holds if `getElementTypeName()` exists. + */ + final predicate hasElementTypeName() { exists(this.getElementTypeName()) } + + /** + * Gets the initial value of this variable declaration, if it exists. + */ + Expression getInitialValue() { + result = + Synth::convertExpressionFromRaw(Synth::convertVariableDeclarationToRaw(this) + .(Raw::VariableDeclaration) + .getInitialValue()) + } + + /** + * Holds if `getInitialValue()` exists. + */ + final predicate hasInitialValue() { exists(this.getInitialValue()) } + + /** + * Holds if this variable declaration is const. + */ + predicate isConst() { + Synth::convertVariableDeclarationToRaw(this).(Raw::VariableDeclaration).isConst() + } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/VariableDeclarationInternal.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/VariableDeclarationInternal.qll new file mode 100644 index 000000000000..9e6798f69455 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/VariableDeclarationInternal.qll @@ -0,0 +1,25 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `VariableDeclarationInternal`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.VariableDeclarationImpl::Impl as VariableDeclarationImpl + +/** + * INTERNAL: This module contains the fully generated definition of `VariableDeclarationInternal` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::VariableDeclarationInternal` class directly. + * Use the subclass `VariableDeclarationInternal`, where the following predicates are available. + */ + class VariableDeclarationInternal extends Synth::TVariableDeclarationInternal, + VariableDeclarationImpl::VariableDeclaration + { + override string getAPrimaryQlClass() { result = "VariableDeclarationInternal" } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/VoidType.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/VoidType.qll new file mode 100644 index 000000000000..aae4035252aa --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/VoidType.qll @@ -0,0 +1,23 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `VoidType`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.XppTypeImpl::Impl as XppTypeImpl + +/** + * INTERNAL: This module contains the fully generated definition of `VoidType` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::VoidType` class directly. + * Use the subclass `VoidType`, where the following predicates are available. + */ + class VoidType extends Synth::TVoidType, XppTypeImpl::XppType { + override string getAPrimaryQlClass() { result = "VoidType" } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/WhileStatement.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/WhileStatement.qll new file mode 100644 index 000000000000..ec06953192e0 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/WhileStatement.qll @@ -0,0 +1,55 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `WhileStatement`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.Expression +import codeql.xpp.elements.Statement +import codeql.xpp.elements.internal.StatementImpl::Impl as StatementImpl + +/** + * INTERNAL: This module contains the fully generated definition of `WhileStatement` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::WhileStatement` class directly. + * Use the subclass `WhileStatement`, where the following predicates are available. + */ + class WhileStatement extends Synth::TWhileStatement, StatementImpl::Statement { + override string getAPrimaryQlClass() { result = "WhileStatement" } + + /** + * Gets the condition of this while statement, if it exists. + */ + Expression getCondition() { + result = + Synth::convertExpressionFromRaw(Synth::convertWhileStatementToRaw(this) + .(Raw::WhileStatement) + .getCondition()) + } + + /** + * Holds if `getCondition()` exists. + */ + final predicate hasCondition() { exists(this.getCondition()) } + + /** + * Gets the statement of this while statement, if it exists. + */ + Statement getStatement() { + result = + Synth::convertStatementFromRaw(Synth::convertWhileStatementToRaw(this) + .(Raw::WhileStatement) + .getStatement()) + } + + /** + * Holds if `getStatement()` exists. + */ + final predicate hasStatement() { exists(this.getStatement()) } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/XppTuple.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/XppTuple.qll new file mode 100644 index 000000000000..f116faaa2e92 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/XppTuple.qll @@ -0,0 +1,26 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `XppTuple`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.LocatableImpl::Impl as LocatableImpl + +/** + * INTERNAL: This module contains the fully generated definition of `XppTuple` and should not + * be referenced directly. + */ +module Generated { + /** + * Base of the classes standing in for tuples in the compiler's AST. + * + * The X++ compiler uses CLR tuples for a handful of grouped values, such as a `catch` + * together with its handler body. The schema has no tuple type, so the generator emits a + * named class per tuple-valued property instead. + * INTERNAL: Do not reference the `Generated::XppTuple` class directly. + * Use the subclass `XppTuple`, where the following predicates are available. + */ + class XppTuple extends Synth::TXppTuple, LocatableImpl::Locatable { } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/XppType.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/XppType.qll new file mode 100644 index 000000000000..89b17c07f2f1 --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/XppType.qll @@ -0,0 +1,38 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `XppType`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.AstImpl::Impl as AstImpl + +/** + * INTERNAL: This module contains the fully generated definition of `XppType` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::XppType` class directly. + * Use the subclass `XppType`, where the following predicates are available. + */ + class XppType extends Synth::TXppType, AstImpl::Ast { + /** + * Gets the element type name of this xpp type, if it exists. + */ + string getElementTypeName() { + result = Synth::convertXppTypeToRaw(this).(Raw::XppType).getElementTypeName() + } + + /** + * Holds if `getElementTypeName()` exists. + */ + final predicate hasElementTypeName() { exists(this.getElementTypeName()) } + + /** + * Holds if this xpp type is obsolete. + */ + predicate isObsolete() { Synth::convertXppTypeToRaw(this).(Raw::XppType).isObsolete() } + } +} diff --git a/xpp/ql/lib/codeql/xpp/elements/internal/generated/XppTypeCompilationUnit.qll b/xpp/ql/lib/codeql/xpp/elements/internal/generated/XppTypeCompilationUnit.qll new file mode 100644 index 000000000000..5aaa298eb76b --- /dev/null +++ b/xpp/ql/lib/codeql/xpp/elements/internal/generated/XppTypeCompilationUnit.qll @@ -0,0 +1,41 @@ +// generated by xpp/tools/generate-schema.sh, do not edit +/** + * This module provides the generated definition of `XppTypeCompilationUnit`. + * INTERNAL: Do not import directly. + */ + +private import codeql.xpp.elements.internal.generated.Synth +private import codeql.xpp.elements.internal.generated.Raw +import codeql.xpp.elements.internal.CompilationUnitImpl::Impl as CompilationUnitImpl +import codeql.xpp.elements.XppType + +/** + * INTERNAL: This module contains the fully generated definition of `XppTypeCompilationUnit` and should not + * be referenced directly. + */ +module Generated { + /** + * INTERNAL: Do not reference the `Generated::XppTypeCompilationUnit` class directly. + * Use the subclass `XppTypeCompilationUnit`, where the following predicates are available. + */ + class XppTypeCompilationUnit extends Synth::TXppTypeCompilationUnit, + CompilationUnitImpl::CompilationUnit + { + override string getAPrimaryQlClass() { result = "XppTypeCompilationUnit" } + + /** + * Gets the type of this xpp type compilation unit, if it exists. + */ + XppType getType() { + result = + Synth::convertXppTypeFromRaw(Synth::convertXppTypeCompilationUnitToRaw(this) + .(Raw::XppTypeCompilationUnit) + .getType()) + } + + /** + * Holds if `getType()` exists. + */ + final predicate hasType() { exists(this.getType()) } + } +} diff --git a/xpp/ql/lib/qlpack.yml b/xpp/ql/lib/qlpack.yml new file mode 100644 index 000000000000..9c7649a2af16 --- /dev/null +++ b/xpp/ql/lib/qlpack.yml @@ -0,0 +1,17 @@ +name: microsoft/xpp-all +version: 0.0.1 +groups: + - xpp + - microsoft-all +extractor: xpp +dbscheme: xpp.dbscheme +library: true +dependencies: + codeql/controlflow: ${workspace} + codeql/dataflow: ${workspace} + codeql/mad: ${workspace} + codeql/ssa: ${workspace} + codeql/threat-models: ${workspace} + codeql/typetracking: ${workspace} + codeql/util: ${workspace} +warnOnImplicitThis: true diff --git a/xpp/ql/lib/xpp.dbscheme b/xpp/ql/lib/xpp.dbscheme new file mode 100644 index 000000000000..4e5a88a87574 --- /dev/null +++ b/xpp/ql/lib/xpp.dbscheme @@ -0,0 +1,3960 @@ +// generated by xpp/tools/generate-schema.sh, do not edit + +// from prefix.dbscheme +/** + * The source location of the snapshot. + */ +sourceLocationPrefix( + string prefix: string ref +); + + +// from schema + +@element = + @file +| @locatable +| @location +; + +#keyset[id] +element_is_unknown( + int id: @element ref +); + +files( + unique int id: @file, + string name: string ref +); + +@locatable = + @ast +| @comment +| @error_element +| @xpp_tuple +; + +#keyset[id] +locatable_locations( + int id: @locatable ref, + int location: @location_or_none ref +); + +locations( + unique int id: @location, + int file: @file_or_none ref, + int start_line: int ref, + int start_column: int ref, + int end_line: int ref, + int end_column: int ref +); + +@ast = + @array_specification +| @attribute +| @attribute_expression +| @attribute_list +| @attribute_literal +| @case +| @catch +| @class_access_modifier +| @compilation_unit +| @cross_company +| @expression +| @field_assignment +| @field_specification +| @for_assign +| @insert_field_specification +| @instance_name +| @join_specification +| @modifier +| @order_element +| @qualifier +| @query +| @query_data_source +| @query_data_source_having +| @query_data_source_range +| @query_data_source_relation +| @selection +| @selection_field +| @statement +| @switch_case +| @table_field_reference +| @valid_time_state +| @xpp_type +; + +comments( + unique int id: @comment +); + +#keyset[id] +comment_texts( + int id: @comment ref, + string text: string ref +); + +@error_element = + @unspecified_element +; + +@xpp_tuple = + @attribute_named_parameter_entry +| @compilation_unit_region_entry +| @evaluation_actual_parameter_entry +| @model_element_using_entry +| @switch_statement_case_entry +| @try_statement_catch_entry +; + +array_specifications( + unique int id: @array_specification +); + +#keyset[id] +array_specification_index1s( + int id: @array_specification ref, + int index1: @expression_or_none ref +); + +#keyset[id] +array_specification_index2s( + int id: @array_specification ref, + int index2: @expression_or_none ref +); + +attributes( + unique int id: @attribute +); + +#keyset[id] +attribute_names( + int id: @attribute ref, + string name: string ref +); + +#keyset[id, index] +attribute_named_parameters( + int id: @attribute ref, + int index: int ref, + int named_parameter: @attribute_named_parameter_entry_or_none ref +); + +#keyset[id] +attribute_non_fully_qualified_names( + int id: @attribute ref, + string non_fully_qualified_name: string ref +); + +#keyset[id, index] +attribute_parameters( + int id: @attribute ref, + int index: int ref, + int parameter: @attribute_expression_or_none ref +); + +attribute_expressions( + unique int id: @attribute_expression +); + +#keyset[id] +attribute_expression_literals( + int id: @attribute_expression ref, + int literal: @attribute_literal_or_none ref +); + +attribute_lists( + unique int id: @attribute_list +); + +#keyset[id, index] +attribute_list_attributes( + int id: @attribute_list ref, + int index: int ref, + int attribute: @attribute_or_none ref +); + +#keyset[id] +attribute_list_contains_internal_use_only_attribute( + int id: @attribute_list ref +); + +@attribute_literal = + @container_attribute_literal +| @default_type_attribute_literal +| @enum_attribute_literal +| @intrinsic_attribute_literal +; + +attribute_named_parameter_entries( + unique int id: @attribute_named_parameter_entry +); + +#keyset[id] +attribute_named_parameter_entry_item1s( + int id: @attribute_named_parameter_entry ref, + string item1: string ref +); + +#keyset[id] +attribute_named_parameter_entry_attribute_expressions( + int id: @attribute_named_parameter_entry ref, + int attribute_expression: @attribute_expression_or_none ref +); + +@case = + @case_default +| @case_values +; + +@catch = + @catch_all_values +| @catch_expression +| @catch_update_conflict +; + +class_access_modifiers( + unique int id: @class_access_modifier +); + +#keyset[id] +class_access_modifier_class_modifiers( + int id: @class_access_modifier ref, + string class_modifiers: string ref +); + +@compilation_unit = + @declaration +| @expression_compilation_unit +| @method_or_delegate +| @model_element +| @xpp_type_compilation_unit +; + +#keyset[id] +compilation_unit_comments( + int id: @compilation_unit ref, + int comments: @comment_or_none ref +); + +#keyset[id] +compilation_unit_is_name_escaped( + int id: @compilation_unit ref +); + +#keyset[id] +compilation_unit_names( + int id: @compilation_unit ref, + string name: string ref +); + +#keyset[id] +compilation_unit_needs_transformation( + int id: @compilation_unit ref +); + +#keyset[id, index] +compilation_unit_regions( + int id: @compilation_unit ref, + int index: int ref, + int region: @compilation_unit_region_entry_or_none ref +); + +compilation_unit_region_entries( + unique int id: @compilation_unit_region_entry +); + +#keyset[id] +compilation_unit_region_entry_comments( + int id: @compilation_unit_region_entry ref, + int comment: @comment_or_none ref +); + +#keyset[id] +compilation_unit_region_entry_comment2s( + int id: @compilation_unit_region_entry ref, + int comment2: @comment_or_none ref +); + +@cross_company = + @cross_company_all +| @cross_company_container +; + +evaluation_actual_parameter_entries( + unique int id: @evaluation_actual_parameter_entry +); + +#keyset[id] +evaluation_actual_parameter_entry_item1( + int id: @evaluation_actual_parameter_entry ref +); + +#keyset[id] +evaluation_actual_parameter_entry_expressions( + int id: @evaluation_actual_parameter_entry ref, + int expression: @expression_or_none ref +); + +@expression = + @binary_expression +| @conditional_expression +| @empty_expression +| @evaluation +| @field_expression +| @intrinsic +| @is_as_expression +| @literal_expression +| @new_clr_array_expression +| @placeholder +| @table_lookup_expression +| @unary_expression +; + +#keyset[id] +expression_is_const( + int id: @expression ref +); + +#keyset[id] +expression_transformations( + int id: @expression ref, + int transformation: @expression_or_none ref +); + +field_assignments( + unique int id: @field_assignment +); + +#keyset[id] +field_assignment_expressions( + int id: @field_assignment ref, + int expression: @expression_or_none ref +); + +#keyset[id] +field_assignment_extension_names( + int id: @field_assignment ref, + string extension_name: string ref +); + +#keyset[id] +field_assignment_field_names( + int id: @field_assignment ref, + string field_name: string ref +); + +#keyset[id] +field_assignment_indices( + int id: @field_assignment ref, + int index: int ref +); + +@field_specification = + @qualified_field +| @qualified_numbered_field +| @qualified_static_field +| @simple_field +| @static_field +; + +#keyset[id] +field_specification_array_indices( + int id: @field_specification ref, + int array_index: @expression_or_none ref +); + +#keyset[id] +field_specification_element_type_names( + int id: @field_specification ref, + string element_type_name: string ref +); + +#keyset[id] +field_specification_is_const( + int id: @field_specification ref +); + +#keyset[id] +field_specification_is_internal( + int id: @field_specification ref +); + +#keyset[id] +field_specification_is_private( + int id: @field_specification ref +); + +#keyset[id] +field_specification_is_protected( + int id: @field_specification ref +); + +#keyset[id] +field_specification_is_public( + int id: @field_specification ref +); + +#keyset[id] +field_specification_is_read_only( + int id: @field_specification ref +); + +#keyset[id] +field_specification_is_static( + int id: @field_specification ref +); + +#keyset[id] +field_specification_qualifiers( + int id: @field_specification ref, + int qualifier: @qualifier_or_none ref +); + +@for_assign = + @for_declaration_assign +| @for_expression_assign +| @for_field_post_decrement +| @for_field_post_increment +| @for_field_pre_decrement +| @for_field_pre_increment +; + +#keyset[id] +for_assign_field_specifications( + int id: @for_assign ref, + int field_specification: @field_specification_or_none ref +); + +insert_field_specifications( + unique int id: @insert_field_specification +); + +#keyset[id] +insert_field_specification_array_indices( + int id: @insert_field_specification ref, + int array_index: int ref +); + +#keyset[id] +insert_field_specification_extension_names( + int id: @insert_field_specification ref, + string extension_name: string ref +); + +#keyset[id] +insert_field_specification_is_extension( + int id: @insert_field_specification ref +); + +#keyset[id] +insert_field_specification_names( + int id: @insert_field_specification ref, + string name: string ref +); + +@instance_name = + @qualified_instance_name +| @simple_instance_name +; + +join_specifications( + unique int id: @join_specification +); + +#keyset[id] +join_specification_kinds( + int id: @join_specification ref, + string kind: string ref +); + +#keyset[id] +join_specification_queries( + int id: @join_specification ref, + int query: @query_or_none ref +); + +model_element_using_entries( + unique int id: @model_element_using_entry +); + +#keyset[id] +model_element_using_entry_item2s( + int id: @model_element_using_entry ref, + string item2: string ref +); + +#keyset[id] +model_element_using_entry_item3s( + int id: @model_element_using_entry ref, + string item3: string ref +); + +modifiers( + unique int id: @modifier +); + +#keyset[id] +modifier_modifiers( + int id: @modifier ref, + string modifiers: string ref +); + +@order_element = + @global_order_element +| @simple_order_element +; + +#keyset[id] +order_element_directions( + int id: @order_element ref, + string direction: string ref +); + +#keyset[id] +order_element_fields( + int id: @order_element ref, + string field: string ref +); + +#keyset[id] +order_element_indices( + int id: @order_element ref, + int index: int ref +); + +@qualifier = + @expression_qualifier +| @simple_qualifier +; + +queries( + unique int id: @query +); + +#keyset[id] +query_buffer_names( + int id: @query ref, + string buffer_name: string ref +); + +#keyset[id] +query_cross_companies( + int id: @query ref, + int cross_company: @cross_company_or_none ref +); + +#keyset[id, index] +query_group_by_elements( + int id: @query ref, + int index: int ref, + int group_by_element: @order_element_or_none ref +); + +#keyset[id] +query_index_names( + int id: @query ref, + string index_name: string ref +); + +#keyset[id] +query_joins( + int id: @query ref, + int joins: @join_specification_or_none ref +); + +#keyset[id, index] +query_order_by_elements( + int id: @query ref, + int index: int ref, + int order_by_element: @order_element_or_none ref +); + +#keyset[id] +query_selections( + int id: @query ref, + int selection: @selection_or_none ref +); + +#keyset[id, index] +query_selection_hints( + int id: @query ref, + int index: int ref, + string selection_hint: string ref +); + +#keyset[id] +query_uses_hint( + int id: @query ref +); + +#keyset[id] +query_valid_time_states( + int id: @query ref, + int valid_time_state: @valid_time_state_or_none ref +); + +#keyset[id] +query_wheres( + int id: @query ref, + int where: @expression_or_none ref +); + +query_data_sources( + unique int id: @query_data_source +); + +#keyset[id, index] +query_data_source_data_sources( + int id: @query_data_source ref, + int index: int ref, + int data_source: @query_data_source_or_none ref +); + +#keyset[id] +query_data_source_element_type_names( + int id: @query_data_source ref, + string element_type_name: string ref +); + +#keyset[id] +query_data_source_fetch_modes( + int id: @query_data_source ref, + string fetch_mode: string ref +); + +#keyset[id, index] +query_data_source_fields( + int id: @query_data_source ref, + int index: int ref, + string field: string ref +); + +#keyset[id] +query_data_source_first_fast( + int id: @query_data_source ref +); + +#keyset[id] +query_data_source_first_only( + int id: @query_data_source ref +); + +#keyset[id, index] +query_data_source_group_bies( + int id: @query_data_source ref, + int index: int ref, + int group_by: @global_order_element_or_none ref +); + +#keyset[id, index] +query_data_source_having_prop( + int id: @query_data_source ref, + int index: int ref, + int having: @query_data_source_having_or_none ref +); + +#keyset[id] +query_data_source_join_modes( + int id: @query_data_source ref, + string join_mode: string ref +); + +#keyset[id] +query_data_source_names( + int id: @query_data_source ref, + string name: string ref +); + +#keyset[id, index] +query_data_source_order_bies( + int id: @query_data_source ref, + int index: int ref, + int order_by: @global_order_element_or_none ref +); + +#keyset[id] +query_data_source_parent_data_sources( + int id: @query_data_source ref, + int parent_data_source: @query_data_source_or_none ref +); + +#keyset[id] +query_data_source_path_contributions( + int id: @query_data_source ref, + string path_contribution: string ref +); + +#keyset[id, index] +query_data_source_ranges_prop( + int id: @query_data_source ref, + int index: int ref, + int range: @query_data_source_range_or_none ref +); + +#keyset[id, index] +query_data_source_relations_prop( + int id: @query_data_source ref, + int index: int ref, + int relation: @query_data_source_relation_or_none ref +); + +#keyset[id] +query_data_source_select_with_repeatable_read( + int id: @query_data_source ref +); + +#keyset[id] +query_data_source_tables( + int id: @query_data_source ref, + string table: string ref +); + +#keyset[id] +query_data_source_update( + int id: @query_data_source ref +); + +query_data_source_havings( + unique int id: @query_data_source_having +); + +#keyset[id] +query_data_source_having_data_source_names( + int id: @query_data_source_having ref, + string data_source_name: string ref +); + +#keyset[id] +query_data_source_having_selections( + int id: @query_data_source_having ref, + int selection: @selection_field_or_none ref +); + +#keyset[id] +query_data_source_having_values( + int id: @query_data_source_having ref, + string value: string ref +); + +query_data_source_ranges( + unique int id: @query_data_source_range +); + +#keyset[id] +query_data_source_range_fields( + int id: @query_data_source_range ref, + string field: string ref +); + +#keyset[id] +query_data_source_range_values( + int id: @query_data_source_range ref, + string value: string ref +); + +query_data_source_relations( + unique int id: @query_data_source_relation +); + +#keyset[id] +query_data_source_relation_fields( + int id: @query_data_source_relation ref, + string field: string ref +); + +#keyset[id] +query_data_source_relation_join_data_sources( + int id: @query_data_source_relation ref, + string join_data_source: string ref +); + +#keyset[id] +query_data_source_relation_related_fields( + int id: @query_data_source_relation ref, + string related_field: string ref +); + +@selection = + @all_fields_selection +| @explicit_selection +| @implicit_selection +; + +@selection_field = + @aggregate_selection +| @field_selection +; + +#keyset[id] +selection_field_extension_names( + int id: @selection_field ref, + string extension_name: string ref +); + +#keyset[id] +selection_field_fields( + int id: @selection_field ref, + string field: string ref +); + +@statement = + @assignment_statement +| @break_statement +| @breakpoint_statement +| @change_statement +| @compound_statement +| @continue_statement +| @delete_statement +| @do_while_statement +| @empty_statement +| @expression_statement +| @find_statement +| @flush_statement +| @for_statement +| @if_statement +| @if_then_else_statement +| @insert_statement +| @local_declarations_statement +| @move_cursor_statement +| @print_statement +| @retry_statement +| @return_statement +| @search_statement +| @switch_statement +| @throw_statement +| @try_statement +| @tts_statement +| @unchecked_statement +| @update_statement +| @using_statement +| @while_statement +; + +#keyset[id] +statement_comments( + int id: @statement ref, + string comments: string ref +); + +switch_cases( + unique int id: @switch_case +); + +switch_statement_case_entries( + unique int id: @switch_statement_case_entry +); + +#keyset[id] +switch_statement_case_entry_cases( + int id: @switch_statement_case_entry ref, + int case_: @case_or_none ref +); + +#keyset[id, index] +switch_statement_case_entry_statements( + int id: @switch_statement_case_entry ref, + int index: int ref, + int statement: @statement_or_none ref +); + +@table_field_reference = + @named_field_reference +| @numbered_field_reference +; + +#keyset[id] +table_field_reference_indices( + int id: @table_field_reference ref, + int index: @expression_or_none ref +); + +try_statement_catch_entries( + unique int id: @try_statement_catch_entry +); + +#keyset[id] +try_statement_catch_entry_catches( + int id: @try_statement_catch_entry ref, + int catch: @catch_or_none ref +); + +#keyset[id] +try_statement_catch_entry_statements( + int id: @try_statement_catch_entry ref, + int statement: @statement_or_none ref +); + +unspecified_elements( + unique int id: @unspecified_element, + string property: string ref, + string error: string ref +); + +#keyset[id] +unspecified_element_parents( + int id: @unspecified_element ref, + int parent: @element ref +); + +#keyset[id] +unspecified_element_indices( + int id: @unspecified_element ref, + int index: int ref +); + +@valid_time_state = + @valid_time_state_date +| @valid_time_state_range +; + +@xpp_type = + @any_type +| @boolean_type +| @container_type +| @date_time_type +| @date_type +| @dbl_type +| @enumeration_type +| @generic_xpp_type +| @guid_type +| @int64_type +| @int_type +| @provided_type +| @string_type +| @var_type +| @void_type +; + +#keyset[id] +xpp_type_element_type_names( + int id: @xpp_type ref, + string element_type_name: string ref +); + +#keyset[id] +xpp_type_is_obsolete( + int id: @xpp_type ref +); + +@aggregate_selection = + @avg_aggregate_selection +| @count_aggregate_selection +| @max_aggregate_selection +| @min_aggregate_selection +| @sum_aggregate_selection +; + +all_fields_selections( + unique int id: @all_fields_selection +); + +any_types( + unique int id: @any_type +); + +@assignment_statement = + @assign_multiple_field_statement +| @assignment_single_field +; + +@binary_expression = + @add_expression +| @and_expression +| @divide_expression +| @in_expression +| @integer_divide_expression +| @mod_expression +| @multiply_expression +| @or_expression +| @physical_and_expression +| @physical_or_expression +| @physical_xor_expression +| @relational_expression +| @shift_left_expression +| @shift_right_expression +| @subtract_expression +; + +#keyset[id] +binary_expression_lefts( + int id: @binary_expression ref, + int left: @expression_or_none ref +); + +#keyset[id] +binary_expression_rights( + int id: @binary_expression ref, + int right: @expression_or_none ref +); + +boolean_types( + unique int id: @boolean_type +); + +break_statements( + unique int id: @break_statement +); + +breakpoint_statements( + unique int id: @breakpoint_statement +); + +case_defaults( + unique int id: @case_default +); + +case_values( + unique int id: @case_values +); + +#keyset[id, index] +case_values_values( + int id: @case_values ref, + int index: int ref, + int value: @expression_or_none ref +); + +catch_all_values( + unique int id: @catch_all_values +); + +catch_expressions( + unique int id: @catch_expression +); + +#keyset[id] +catch_expression_expressions( + int id: @catch_expression ref, + int expression: @expression_or_none ref +); + +catch_update_conflicts( + unique int id: @catch_update_conflict +); + +#keyset[id] +catch_update_conflict_expressions( + int id: @catch_update_conflict ref, + int expression: @expression_or_none ref +); + +#keyset[id] +catch_update_conflict_instances( + int id: @catch_update_conflict ref, + int instance: @instance_name_or_none ref +); + +@change_statement = + @change_company_statement +; + +#keyset[id] +change_statement_expressions( + int id: @change_statement ref, + int expression: @expression_or_none ref +); + +#keyset[id] +change_statement_statements( + int id: @change_statement ref, + int statement: @statement_or_none ref +); + +compound_statements( + unique int id: @compound_statement +); + +#keyset[id, index] +compound_statement_contents( + int id: @compound_statement ref, + int index: int ref, + int content: @statement_or_none ref +); + +conditional_expressions( + unique int id: @conditional_expression +); + +#keyset[id] +conditional_expression_conditions( + int id: @conditional_expression ref, + int condition: @expression_or_none ref +); + +#keyset[id] +conditional_expression_else_parts( + int id: @conditional_expression ref, + int else_part: @expression_or_none ref +); + +#keyset[id] +conditional_expression_if_parts( + int id: @conditional_expression ref, + int if_part: @expression_or_none ref +); + +container_attribute_literals( + unique int id: @container_attribute_literal +); + +#keyset[id, index] +container_attribute_literal_values( + int id: @container_attribute_literal ref, + int index: int ref, + int value: @attribute_expression_or_none ref +); + +container_types( + unique int id: @container_type +); + +continue_statements( + unique int id: @continue_statement +); + +cross_company_alls( + unique int id: @cross_company_all +); + +cross_company_containers( + unique int id: @cross_company_container +); + +#keyset[id] +cross_company_container_containers( + int id: @cross_company_container ref, + int container: @expression_or_none ref +); + +date_time_types( + unique int id: @date_time_type +); + +date_types( + unique int id: @date_type +); + +dbl_types( + unique int id: @dbl_type +); + +@declaration = + @field_declaration +| @local_declaration +; + +#keyset[id] +declaration_array_specifications( + int id: @declaration ref, + int array_specification: @array_specification_or_none ref +); + +#keyset[id, index] +declaration_modifier_lists( + int id: @declaration ref, + int index: int ref, + int modifier_list: @modifier_or_none ref +); + +#keyset[id] +declaration_modifiers( + int id: @declaration ref, + string modifiers: string ref +); + +#keyset[id] +declaration_types( + int id: @declaration ref, + int type_: @xpp_type_or_none ref +); + +@default_type_attribute_literal = + @boolean_attribute_literal +| @date_attribute_literal +| @date_time_attribute_literal +| @dbl_attribute_literal +| @guid_attribute_literal +| @int64_attribute_literal +| @int_attribute_literal +| @string_attribute_literal +; + +#keyset[id] +default_type_attribute_literal_scanned_literal_values( + int id: @default_type_attribute_literal ref, + string scanned_literal_value: string ref +); + +delete_statements( + unique int id: @delete_statement +); + +#keyset[id] +delete_statement_queries( + int id: @delete_statement ref, + int query: @query_or_none ref +); + +do_while_statements( + unique int id: @do_while_statement +); + +#keyset[id] +do_while_statement_conditions( + int id: @do_while_statement ref, + int condition: @expression_or_none ref +); + +#keyset[id] +do_while_statement_statements( + int id: @do_while_statement ref, + int statement: @statement_or_none ref +); + +empty_expressions( + unique int id: @empty_expression +); + +empty_statements( + unique int id: @empty_statement +); + +enum_attribute_literals( + unique int id: @enum_attribute_literal +); + +#keyset[id] +enum_attribute_literal_literals( + int id: @enum_attribute_literal ref, + string literal: string ref +); + +#keyset[id] +enum_attribute_literal_type_names( + int id: @enum_attribute_literal ref, + string type_name: string ref +); + +enumeration_types( + unique int id: @enumeration_type +); + +#keyset[id] +enumeration_type_enumerated_types( + int id: @enumeration_type ref, + string enumerated_type: string ref +); + +#keyset[id] +enumeration_type_full_names( + int id: @enumeration_type ref, + string full_name: string ref +); + +#keyset[id] +enumeration_type_namespaces( + int id: @enumeration_type ref, + string namespace: string ref +); + +@evaluation = + @generic_evaluation +| @new_call +| @next_expression +| @provided_type_static_call +| @super_call +; + +#keyset[id, index] +evaluation_actual_parameters( + int id: @evaluation ref, + int index: int ref, + int actual_parameter: @evaluation_actual_parameter_entry_or_none ref +); + +explicit_selections( + unique int id: @explicit_selection +); + +#keyset[id, index] +explicit_selection_fields( + int id: @explicit_selection ref, + int index: int ref, + int field: @selection_field_or_none ref +); + +expression_compilation_units( + unique int id: @expression_compilation_unit +); + +#keyset[id] +expression_compilation_unit_expressions( + int id: @expression_compilation_unit ref, + int expression: @expression_or_none ref +); + +#keyset[id] +expression_compilation_unit_path_contributions( + int id: @expression_compilation_unit ref, + string path_contribution: string ref +); + +expression_qualifiers( + unique int id: @expression_qualifier +); + +#keyset[id] +expression_qualifier_expressions( + int id: @expression_qualifier ref, + int expression: @expression_or_none ref +); + +expression_statements( + unique int id: @expression_statement +); + +#keyset[id] +expression_statement_element_type_names( + int id: @expression_statement ref, + string element_type_name: string ref +); + +#keyset[id] +expression_statement_expressions( + int id: @expression_statement ref, + int expression: @expression_or_none ref +); + +@field_expression = + @field_expression_internal +| @qualified_static_field_expression +; + +#keyset[id] +field_expression_fields( + int id: @field_expression ref, + int field: @field_specification_or_none ref +); + +#keyset[id] +field_expression_is_enum( + int id: @field_expression ref +); + +field_selections( + unique int id: @field_selection +); + +#keyset[id] +field_selection_indices( + int id: @field_selection ref, + int index: int ref +); + +find_statements( + unique int id: @find_statement +); + +#keyset[id] +find_statement_queries( + int id: @find_statement ref, + int query: @query_or_none ref +); + +flush_statements( + unique int id: @flush_statement +); + +#keyset[id, index] +flush_statement_id_lists( + int id: @flush_statement ref, + int index: int ref, + string id_list: string ref +); + +for_declaration_assigns( + unique int id: @for_declaration_assign +); + +#keyset[id, index] +for_declaration_assign_initialization_declarations( + int id: @for_declaration_assign ref, + int index: int ref, + int initialization_declaration: @variable_declaration_or_none ref +); + +@for_expression_assign = + @for_field_assign +| @for_field_decrement_assign +| @for_field_increment_assign +; + +#keyset[id] +for_expression_assign_expressions( + int id: @for_expression_assign ref, + int expression: @expression_or_none ref +); + +for_field_post_decrements( + unique int id: @for_field_post_decrement +); + +for_field_post_increments( + unique int id: @for_field_post_increment +); + +for_field_pre_decrements( + unique int id: @for_field_pre_decrement +); + +for_field_pre_increments( + unique int id: @for_field_pre_increment +); + +for_statements( + unique int id: @for_statement +); + +#keyset[id] +for_statement_conditions( + int id: @for_statement ref, + int condition: @expression_or_none ref +); + +#keyset[id] +for_statement_initializations( + int id: @for_statement ref, + int initialization: @for_assign_or_none ref +); + +#keyset[id] +for_statement_statements( + int id: @for_statement ref, + int statement: @statement_or_none ref +); + +#keyset[id] +for_statement_updates( + int id: @for_statement ref, + int update: @for_assign_or_none ref +); + +@generic_xpp_type = + @clr_type +| @named_type +; + +#keyset[id, index] +generic_xpp_type_type_argument_lists( + int id: @generic_xpp_type ref, + int index: int ref, + int type_argument_list: @xpp_type_or_none ref +); + +global_order_elements( + unique int id: @global_order_element +); + +#keyset[id] +global_order_element_extension_names( + int id: @global_order_element ref, + string extension_name: string ref +); + +#keyset[id] +global_order_element_tables( + int id: @global_order_element ref, + string table: string ref +); + +guid_types( + unique int id: @guid_type +); + +if_statements( + unique int id: @if_statement +); + +#keyset[id] +if_statement_conditions( + int id: @if_statement ref, + int condition: @expression_or_none ref +); + +#keyset[id] +if_statement_consequents( + int id: @if_statement ref, + int consequent: @statement_or_none ref +); + +if_then_else_statements( + unique int id: @if_then_else_statement +); + +#keyset[id] +if_then_else_statement_antecedents( + int id: @if_then_else_statement ref, + int antecedent: @statement_or_none ref +); + +#keyset[id] +if_then_else_statement_conditions( + int id: @if_then_else_statement ref, + int condition: @expression_or_none ref +); + +#keyset[id] +if_then_else_statement_consequents( + int id: @if_then_else_statement ref, + int consequent: @statement_or_none ref +); + +implicit_selections( + unique int id: @implicit_selection +); + +insert_statements( + unique int id: @insert_statement +); + +#keyset[id] +insert_statement_cross_companies( + int id: @insert_statement ref, + int cross_company: @cross_company_or_none ref +); + +#keyset[id, index] +insert_statement_fields( + int id: @insert_statement ref, + int index: int ref, + int field: @insert_field_specification_or_none ref +); + +#keyset[id] +insert_statement_queries( + int id: @insert_statement ref, + int query: @query_or_none ref +); + +#keyset[id] +insert_statement_tables( + int id: @insert_statement ref, + string table: string ref +); + +int64_types( + unique int id: @int64_type +); + +int_types( + unique int id: @int_type +); + +intrinsics( + unique int id: @intrinsic +); + +#keyset[id] +intrinsic_arg1s( + int id: @intrinsic ref, + string arg1: string ref +); + +#keyset[id] +intrinsic_arg2s( + int id: @intrinsic ref, + string arg2: string ref +); + +#keyset[id] +intrinsic_arg3s( + int id: @intrinsic ref, + string arg3: string ref +); + +#keyset[id] +intrinsic_names( + int id: @intrinsic ref, + string name: string ref +); + +intrinsic_attribute_literals( + unique int id: @intrinsic_attribute_literal +); + +#keyset[id] +intrinsic_attribute_literal_arg1s( + int id: @intrinsic_attribute_literal ref, + string arg1: string ref +); + +#keyset[id] +intrinsic_attribute_literal_arg2s( + int id: @intrinsic_attribute_literal ref, + string arg2: string ref +); + +#keyset[id] +intrinsic_attribute_literal_arg3s( + int id: @intrinsic_attribute_literal ref, + string arg3: string ref +); + +#keyset[id] +intrinsic_attribute_literal_function_names( + int id: @intrinsic_attribute_literal ref, + string function_name: string ref +); + +@is_as_expression = + @as_clr_expression +| @as_expression +| @is_clr_expression +| @is_expression +; + +#keyset[id] +is_as_expression_expressions( + int id: @is_as_expression ref, + int expression: @expression_or_none ref +); + +#keyset[id] +is_as_expression_type_names( + int id: @is_as_expression ref, + string type_name: string ref +); + +@literal_expression = + @clr_enumeration_literal_expression +| @container_literal_expression +| @default_type_literal_expression +| @enumeration_literal_expression +| @null_literal_expression +; + +local_declarations_statements( + unique int id: @local_declarations_statement +); + +#keyset[id, index] +local_declarations_statement_declarations( + int id: @local_declarations_statement ref, + int index: int ref, + int declaration: @local_declaration_or_none ref +); + +@method_or_delegate = + @delegate +| @method +; + +#keyset[id] +method_or_delegate_attributes( + int id: @method_or_delegate ref, + int attributes: @attribute_list_or_none ref +); + +#keyset[id, index] +method_or_delegate_modifier_lists( + int id: @method_or_delegate ref, + int index: int ref, + int modifier_list: @modifier_or_none ref +); + +#keyset[id, index] +method_or_delegate_parameters( + int id: @method_or_delegate ref, + int index: int ref, + int parameter: @parameter_declaration_or_none ref +); + +#keyset[id] +method_or_delegate_path_contributions( + int id: @method_or_delegate ref, + string path_contribution: string ref +); + +#keyset[id] +method_or_delegate_types( + int id: @method_or_delegate ref, + int type_: @xpp_type_or_none ref +); + +#keyset[id, index] +method_or_delegate_type_parameters( + int id: @method_or_delegate ref, + int index: int ref, + string type_parameter: string ref +); + +@model_element = + @class_or_interface +| @form_model_element +| @form_nested_element +| @query_model_element +| @table +; + +#keyset[id, index] +model_element_base_methods( + int id: @model_element ref, + int index: int ref, + int base_method: @method_or_delegate_or_none ref +); + +#keyset[id, index] +model_element_extend_generic_parameters( + int id: @model_element ref, + int index: int ref, + int extend_generic_parameter: @xpp_type_or_none ref +); + +#keyset[id] +model_element_full_names( + int id: @model_element ref, + string full_name: string ref +); + +#keyset[id] +model_element_full_name_no_default_namespaces( + int id: @model_element ref, + string full_name_no_default_namespace: string ref +); + +#keyset[id] +model_element_is_internal( + int id: @model_element ref +); + +#keyset[id] +model_element_is_kernel( + int id: @model_element ref +); + +#keyset[id] +model_element_is_obsolete( + int id: @model_element ref +); + +#keyset[id] +model_element_is_private( + int id: @model_element ref +); + +#keyset[id] +model_element_is_public( + int id: @model_element ref +); + +#keyset[id, index] +model_element_methods( + int id: @model_element ref, + int index: int ref, + int method: @method_or_delegate_or_none ref +); + +#keyset[id] +model_element_model_ids( + int id: @model_element ref, + int model_id: int ref +); + +#keyset[id, index] +model_element_modifier_lists( + int id: @model_element ref, + int index: int ref, + int modifier_list: @class_access_modifier_or_none ref +); + +#keyset[id] +model_element_modifiers( + int id: @model_element ref, + string modifiers: string ref +); + +#keyset[id] +model_element_namespaces( + int id: @model_element ref, + string namespace: string ref +); + +#keyset[id, index] +model_element_nested_classes( + int id: @model_element ref, + int index: int ref, + int nested_class: @class_or_interface_or_none ref +); + +#keyset[id] +model_element_path_contributions( + int id: @model_element ref, + string path_contribution: string ref +); + +#keyset[id, index] +model_element_type_parameters( + int id: @model_element ref, + int index: int ref, + string type_parameter: string ref +); + +#keyset[id, index] +model_element_usings( + int id: @model_element ref, + int index: int ref, + int using: @model_element_using_entry_or_none ref +); + +#keyset[id] +model_element_visibilities( + int id: @model_element ref, + string visibility: string ref +); + +move_cursor_statements( + unique int id: @move_cursor_statement +); + +#keyset[id] +move_cursor_statement_selections( + int id: @move_cursor_statement ref, + int selection: @selection_or_none ref +); + +#keyset[id] +move_cursor_statement_tables( + int id: @move_cursor_statement ref, + string table: string ref +); + +named_field_references( + unique int id: @named_field_reference +); + +#keyset[id] +named_field_reference_extension_names( + int id: @named_field_reference ref, + string extension_name: string ref +); + +#keyset[id] +named_field_reference_field_names( + int id: @named_field_reference ref, + string field_name: string ref +); + +new_clr_array_expressions( + unique int id: @new_clr_array_expression +); + +#keyset[id] +new_clr_array_expression_full_names( + int id: @new_clr_array_expression ref, + string full_name: string ref +); + +#keyset[id, index] +new_clr_array_expression_rectangular_dimensions( + int id: @new_clr_array_expression ref, + int index: int ref, + int rectangular_dimension: int ref +); + +#keyset[id, index] +new_clr_array_expression_sizes( + int id: @new_clr_array_expression ref, + int index: int ref, + int size: @expression_or_none ref +); + +#keyset[id, index] +new_clr_array_expression_type_argument_lists( + int id: @new_clr_array_expression ref, + int index: int ref, + int type_argument_list: @xpp_type_or_none ref +); + +numbered_field_references( + unique int id: @numbered_field_reference +); + +#keyset[id] +numbered_field_reference_field_numbers( + int id: @numbered_field_reference ref, + int field_number: @expression_or_none ref +); + +placeholders( + unique int id: @placeholder +); + +print_statements( + unique int id: @print_statement +); + +#keyset[id, index] +print_statement_expressions( + int id: @print_statement ref, + int index: int ref, + int expression: @expression_or_none ref +); + +provided_types( + unique int id: @provided_type +); + +#keyset[id, index] +provided_type_argument_lists( + int id: @provided_type ref, + int index: int ref, + int argument_list: @expression_or_none ref +); + +#keyset[id] +provided_type_names( + int id: @provided_type ref, + string name: string ref +); + +qualified_fields( + unique int id: @qualified_field +); + +#keyset[id] +qualified_field_extension_names( + int id: @qualified_field ref, + string extension_name: string ref +); + +#keyset[id] +qualified_field_names( + int id: @qualified_field ref, + string name: string ref +); + +qualified_instance_names( + unique int id: @qualified_instance_name +); + +#keyset[id] +qualified_instance_name_indices( + int id: @qualified_instance_name ref, + int index: @expression_or_none ref +); + +#keyset[id] +qualified_instance_name_names( + int id: @qualified_instance_name ref, + string name: string ref +); + +#keyset[id] +qualified_instance_name_qualifiers( + int id: @qualified_instance_name ref, + int qualifier: @qualifier_or_none ref +); + +qualified_numbered_fields( + unique int id: @qualified_numbered_field +); + +#keyset[id] +qualified_numbered_field_field_numbers( + int id: @qualified_numbered_field ref, + int field_number: @expression_or_none ref +); + +qualified_static_fields( + unique int id: @qualified_static_field +); + +#keyset[id] +qualified_static_field_class_names( + int id: @qualified_static_field ref, + string class_name: string ref +); + +#keyset[id] +qualified_static_field_is_enum( + int id: @qualified_static_field ref +); + +#keyset[id] +qualified_static_field_names( + int id: @qualified_static_field ref, + string name: string ref +); + +retry_statements( + unique int id: @retry_statement +); + +return_statements( + unique int id: @return_statement +); + +#keyset[id] +return_statement_expressions( + int id: @return_statement ref, + int expression: @expression_or_none ref +); + +search_statements( + unique int id: @search_statement +); + +#keyset[id] +search_statement_queries( + int id: @search_statement ref, + int query: @query_or_none ref +); + +#keyset[id] +search_statement_statements( + int id: @search_statement ref, + int statement: @statement_or_none ref +); + +simple_fields( + unique int id: @simple_field +); + +#keyset[id] +simple_field_extension_names( + int id: @simple_field ref, + string extension_name: string ref +); + +#keyset[id] +simple_field_is_name_escaped( + int id: @simple_field ref +); + +#keyset[id] +simple_field_names( + int id: @simple_field ref, + string name: string ref +); + +simple_instance_names( + unique int id: @simple_instance_name +); + +#keyset[id] +simple_instance_name_indices( + int id: @simple_instance_name ref, + int index: @expression_or_none ref +); + +#keyset[id] +simple_instance_name_names( + int id: @simple_instance_name ref, + string name: string ref +); + +simple_order_elements( + unique int id: @simple_order_element +); + +#keyset[id] +simple_order_element_extension_names( + int id: @simple_order_element ref, + string extension_name: string ref +); + +@simple_qualifier = + @simple_qualifier_internal +| @static_qualifier +; + +#keyset[id] +simple_qualifier_names( + int id: @simple_qualifier ref, + string name: string ref +); + +static_fields( + unique int id: @static_field +); + +#keyset[id] +static_field_class_names( + int id: @static_field ref, + string class_name: string ref +); + +#keyset[id] +static_field_names( + int id: @static_field ref, + string name: string ref +); + +@string_type = + @string_length_type +| @string_type_internal +; + +switch_statements( + unique int id: @switch_statement +); + +#keyset[id, index] +switch_statement_cases( + int id: @switch_statement ref, + int index: int ref, + int case_: @switch_statement_case_entry_or_none ref +); + +#keyset[id] +switch_statement_selectors( + int id: @switch_statement ref, + int selector: @expression_or_none ref +); + +table_lookup_expressions( + unique int id: @table_lookup_expression +); + +#keyset[id] +table_lookup_expression_fields( + int id: @table_lookup_expression ref, + int field: @table_field_reference_or_none ref +); + +#keyset[id] +table_lookup_expression_queries( + int id: @table_lookup_expression ref, + int query: @query_or_none ref +); + +throw_statements( + unique int id: @throw_statement +); + +#keyset[id] +throw_statement_exceptions( + int id: @throw_statement ref, + int exception: @expression_or_none ref +); + +try_statements( + unique int id: @try_statement +); + +#keyset[id, index] +try_statement_catches( + int id: @try_statement ref, + int index: int ref, + int catch: @try_statement_catch_entry_or_none ref +); + +#keyset[id] +try_statement_finallies( + int id: @try_statement ref, + int finally: @statement_or_none ref +); + +#keyset[id] +try_statement_statements( + int id: @try_statement ref, + int statement: @statement_or_none ref +); + +@tts_statement = + @tts_abort_statement +| @tts_begin_statement +| @tts_end_statement +; + +@unary_expression = + @not_expression +| @physical_not_expression +| @unary_minus_expression +; + +#keyset[id] +unary_expression_expressions( + int id: @unary_expression ref, + int expression: @expression_or_none ref +); + +unchecked_statements( + unique int id: @unchecked_statement +); + +#keyset[id] +unchecked_statement_expressions( + int id: @unchecked_statement ref, + int expression: @expression_or_none ref +); + +#keyset[id] +unchecked_statement_statements( + int id: @unchecked_statement ref, + int statement: @statement_or_none ref +); + +update_statements( + unique int id: @update_statement +); + +#keyset[id] +update_statement_cross_companies( + int id: @update_statement ref, + int cross_company: @cross_company_or_none ref +); + +#keyset[id, index] +update_statement_field_assignments( + int id: @update_statement ref, + int index: int ref, + int field_assignment: @field_assignment_or_none ref +); + +#keyset[id, index] +update_statement_hints( + int id: @update_statement ref, + int index: int ref, + string hint: string ref +); + +#keyset[id] +update_statement_joins( + int id: @update_statement ref, + int joins: @join_specification_or_none ref +); + +#keyset[id] +update_statement_tables( + int id: @update_statement ref, + string table: string ref +); + +#keyset[id] +update_statement_wheres( + int id: @update_statement ref, + int where: @expression_or_none ref +); + +using_statements( + unique int id: @using_statement +); + +#keyset[id, index] +using_statement_disposable_object_initializers( + int id: @using_statement ref, + int index: int ref, + int disposable_object_initializer: @variable_declaration_or_none ref +); + +#keyset[id] +using_statement_statements( + int id: @using_statement ref, + int statement: @statement_or_none ref +); + +valid_time_state_dates( + unique int id: @valid_time_state_date +); + +#keyset[id] +valid_time_state_date_date_variables( + int id: @valid_time_state_date ref, + string date_variable: string ref +); + +valid_time_state_ranges( + unique int id: @valid_time_state_range +); + +#keyset[id] +valid_time_state_range_from_date_variables( + int id: @valid_time_state_range ref, + string from_date_variable: string ref +); + +#keyset[id] +valid_time_state_range_to_date_variables( + int id: @valid_time_state_range ref, + string to_date_variable: string ref +); + +var_types( + unique int id: @var_type +); + +void_types( + unique int id: @void_type +); + +while_statements( + unique int id: @while_statement +); + +#keyset[id] +while_statement_conditions( + int id: @while_statement ref, + int condition: @expression_or_none ref +); + +#keyset[id] +while_statement_statements( + int id: @while_statement ref, + int statement: @statement_or_none ref +); + +xpp_type_compilation_units( + unique int id: @xpp_type_compilation_unit +); + +#keyset[id] +xpp_type_compilation_unit_types( + int id: @xpp_type_compilation_unit ref, + int type_: @xpp_type_or_none ref +); + +add_expressions( + unique int id: @add_expression +); + +and_expressions( + unique int id: @and_expression +); + +as_clr_expressions( + unique int id: @as_clr_expression +); + +as_expressions( + unique int id: @as_expression +); + +assign_multiple_field_statements( + unique int id: @assign_multiple_field_statement +); + +#keyset[id] +assign_multiple_field_statement_expressions( + int id: @assign_multiple_field_statement ref, + int expression: @expression_or_none ref +); + +#keyset[id, index] +assign_multiple_field_statement_fields( + int id: @assign_multiple_field_statement ref, + int index: int ref, + int field: @field_specification_or_none ref +); + +@assignment_single_field = + @assign_post_decrement_statement +| @assign_post_increment_statement +| @assign_pre_decrement_statement +| @assign_pre_increment_statement +| @assignment_binary +| @assignment_event_handler_base +; + +#keyset[id] +assignment_single_field_fields( + int id: @assignment_single_field ref, + int field: @field_specification_or_none ref +); + +avg_aggregate_selections( + unique int id: @avg_aggregate_selection +); + +boolean_attribute_literals( + unique int id: @boolean_attribute_literal +); + +change_company_statements( + unique int id: @change_company_statement +); + +@class_or_interface = + @class +| @interface +; + +#keyset[id] +class_or_interface_attributes( + int id: @class_or_interface ref, + int attributes: @attribute_list_or_none ref +); + +#keyset[id] +class_or_interface_element_type_names( + int id: @class_or_interface ref, + string element_type_name: string ref +); + +#keyset[id] +class_or_interface_enclosing_types( + int id: @class_or_interface ref, + int enclosing_type: @model_element_or_none ref +); + +#keyset[id] +class_or_interface_extends( + int id: @class_or_interface ref, + string extends: string ref +); + +#keyset[id] +class_or_interface_is_abstract( + int id: @class_or_interface ref +); + +#keyset[id] +class_or_interface_is_composite_data_entity_view( + int id: @class_or_interface ref +); + +#keyset[id] +class_or_interface_is_final( + int id: @class_or_interface ref +); + +#keyset[id] +class_or_interface_is_nested( + int id: @class_or_interface ref +); + +#keyset[id] +class_or_interface_is_static( + int id: @class_or_interface ref +); + +#keyset[id] +class_or_interface_qualifiers( + int id: @class_or_interface ref, + string qualifier: string ref +); + +clr_enumeration_literal_expressions( + unique int id: @clr_enumeration_literal_expression +); + +#keyset[id] +clr_enumeration_literal_expression_enumeration_literals( + int id: @clr_enumeration_literal_expression ref, + string enumeration_literal: string ref +); + +#keyset[id] +clr_enumeration_literal_expression_enumeration_types( + int id: @clr_enumeration_literal_expression ref, + string enumeration_type: string ref +); + +clr_types( + unique int id: @clr_type +); + +#keyset[id] +clr_type_full_names( + int id: @clr_type ref, + string full_name: string ref +); + +#keyset[id, index] +clr_type_rectangular_dimensions( + int id: @clr_type ref, + int index: int ref, + int rectangular_dimension: int ref +); + +container_literal_expressions( + unique int id: @container_literal_expression +); + +#keyset[id, index] +container_literal_expression_values( + int id: @container_literal_expression ref, + int index: int ref, + int value: @expression_or_none ref +); + +count_aggregate_selections( + unique int id: @count_aggregate_selection +); + +date_attribute_literals( + unique int id: @date_attribute_literal +); + +date_time_attribute_literals( + unique int id: @date_time_attribute_literal +); + +dbl_attribute_literals( + unique int id: @dbl_attribute_literal +); + +@default_type_literal_expression = + @boolean_literal_expression +| @date_literal_expression +| @date_time_literal_expression +| @int64_literal_expression +| @int_literal_expression +| @real_literal_expression +| @string_literal_expression +; + +#keyset[id] +default_type_literal_expression_scanned_literal_values( + int id: @default_type_literal_expression ref, + string scanned_literal_value: string ref +); + +delegates( + unique int id: @delegate +); + +#keyset[id] +delegate_is_static( + int id: @delegate ref +); + +divide_expressions( + unique int id: @divide_expression +); + +enumeration_literal_expressions( + unique int id: @enumeration_literal_expression +); + +#keyset[id] +enumeration_literal_expression_enumeration_literals( + int id: @enumeration_literal_expression ref, + string enumeration_literal: string ref +); + +#keyset[id] +enumeration_literal_expression_enumeration_types( + int id: @enumeration_literal_expression ref, + string enumeration_type: string ref +); + +@field_declaration = + @field_declaration_internal +| @table_field_declaration +; + +#keyset[id] +field_declaration_attributes( + int id: @field_declaration ref, + int attributes: @attribute_list_or_none ref +); + +#keyset[id] +field_declaration_element_type_names( + int id: @field_declaration ref, + string element_type_name: string ref +); + +#keyset[id] +field_declaration_extension_names( + int id: @field_declaration ref, + string extension_name: string ref +); + +#keyset[id] +field_declaration_initial_values( + int id: @field_declaration ref, + int initial_value: @expression_or_none ref +); + +#keyset[id] +field_declaration_is_const( + int id: @field_declaration ref +); + +#keyset[id] +field_declaration_is_extension( + int id: @field_declaration ref +); + +#keyset[id] +field_declaration_is_internal( + int id: @field_declaration ref +); + +#keyset[id] +field_declaration_is_obsolete( + int id: @field_declaration ref +); + +#keyset[id] +field_declaration_is_private( + int id: @field_declaration ref +); + +#keyset[id] +field_declaration_is_protected( + int id: @field_declaration ref +); + +#keyset[id] +field_declaration_is_public( + int id: @field_declaration ref +); + +#keyset[id] +field_declaration_is_read_only( + int id: @field_declaration ref +); + +#keyset[id] +field_declaration_is_static( + int id: @field_declaration ref +); + +field_expression_internals( + unique int id: @field_expression_internal +); + +for_field_assigns( + unique int id: @for_field_assign +); + +for_field_decrement_assigns( + unique int id: @for_field_decrement_assign +); + +for_field_increment_assigns( + unique int id: @for_field_increment_assign +); + +form_model_elements( + unique int id: @form_model_element +); + +#keyset[id] +form_model_element_behaviors( + int id: @form_model_element ref, + int behavior: @class_or_none ref +); + +#keyset[id, index] +form_model_element_controls( + int id: @form_model_element ref, + int index: int ref, + int control: @form_control_or_none ref +); + +#keyset[id, index] +form_model_element_data_sources( + int id: @form_model_element ref, + int index: int ref, + int data_source: @form_data_source_or_none ref +); + +#keyset[id] +form_model_element_element_type_names( + int id: @form_model_element ref, + string element_type_name: string ref +); + +#keyset[id] +form_model_element_full_type_names( + int id: @form_model_element ref, + string full_type_name: string ref +); + +@form_nested_element = + @form_control +| @form_data_field +| @form_data_source +; + +#keyset[id] +form_nested_element_forms( + int id: @form_nested_element ref, + int form: @form_model_element_or_none ref +); + +@generic_evaluation = + @function_call +| @new_clr_call +| @qualified_call +| @qualified_static_call +| @static_method_call +; + +#keyset[id, index] +generic_evaluation_type_argument_lists( + int id: @generic_evaluation ref, + int index: int ref, + int type_argument_list: @xpp_type_or_none ref +); + +guid_attribute_literals( + unique int id: @guid_attribute_literal +); + +in_expressions( + unique int id: @in_expression +); + +int64_attribute_literals( + unique int id: @int64_attribute_literal +); + +int_attribute_literals( + unique int id: @int_attribute_literal +); + +integer_divide_expressions( + unique int id: @integer_divide_expression +); + +is_clr_expressions( + unique int id: @is_clr_expression +); + +is_expressions( + unique int id: @is_expression +); + +@local_declaration = + @function_declaration +| @variable_declaration +; + +max_aggregate_selections( + unique int id: @max_aggregate_selection +); + +methods( + unique int id: @method +); + +#keyset[id, index] +method_declarations_and_statements( + int id: @method ref, + int index: int ref, + int declarations_and_statement: @statement_or_none ref +); + +#keyset[id] +method_has_local_functions( + int id: @method ref +); + +#keyset[id] +method_is_abstract( + int id: @method ref +); + +#keyset[id] +method_is_client( + int id: @method ref +); + +#keyset[id] +method_is_constructor( + int id: @method ref +); + +#keyset[id] +method_is_display( + int id: @method ref +); + +#keyset[id] +method_is_edit( + int id: @method ref +); + +#keyset[id] +method_is_explicit_non_hookable( + int id: @method ref +); + +#keyset[id] +method_is_explicit_non_wrappable( + int id: @method ref +); + +#keyset[id] +method_is_extended_method( + int id: @method ref +); + +#keyset[id] +method_is_final( + int id: @method ref +); + +#keyset[id] +method_is_hookable( + int id: @method ref +); + +#keyset[id] +method_is_hookable_on_chain_of_command( + int id: @method ref +); + +#keyset[id] +method_is_internal( + int id: @method ref +); + +#keyset[id] +method_is_private( + int id: @method ref +); + +#keyset[id] +method_is_protected( + int id: @method ref +); + +#keyset[id] +method_is_public( + int id: @method ref +); + +#keyset[id] +method_is_replaceable( + int id: @method ref +); + +#keyset[id] +method_is_server( + int id: @method ref +); + +#keyset[id] +method_is_static( + int id: @method ref +); + +#keyset[id] +method_is_type_initializer( + int id: @method ref +); + +#keyset[id] +method_is_wrappable( + int id: @method ref +); + +#keyset[id, index] +method_locals( + int id: @method ref, + int index: int ref, + int local: @local_declaration_or_none ref +); + +#keyset[id] +method_modifiers( + int id: @method ref, + string modifiers: string ref +); + +#keyset[id, index] +method_statements( + int id: @method ref, + int index: int ref, + int statement: @statement_or_none ref +); + +min_aggregate_selections( + unique int id: @min_aggregate_selection +); + +mod_expressions( + unique int id: @mod_expression +); + +multiply_expressions( + unique int id: @multiply_expression +); + +@named_type = + @form_element_type +| @named_type_internal +; + +#keyset[id] +named_type_names( + int id: @named_type ref, + string name: string ref +); + +new_calls( + unique int id: @new_call +); + +#keyset[id] +new_call_types( + int id: @new_call ref, + int type_: @xpp_type_or_none ref +); + +next_expressions( + unique int id: @next_expression +); + +#keyset[id] +next_expression_names( + int id: @next_expression ref, + string name: string ref +); + +not_expressions( + unique int id: @not_expression +); + +null_literal_expressions( + unique int id: @null_literal_expression +); + +or_expressions( + unique int id: @or_expression +); + +physical_and_expressions( + unique int id: @physical_and_expression +); + +physical_not_expressions( + unique int id: @physical_not_expression +); + +physical_or_expressions( + unique int id: @physical_or_expression +); + +physical_xor_expressions( + unique int id: @physical_xor_expression +); + +provided_type_static_calls( + unique int id: @provided_type_static_call +); + +#keyset[id] +provided_type_static_call_method_names( + int id: @provided_type_static_call ref, + string method_name: string ref +); + +#keyset[id] +provided_type_static_call_provided_types( + int id: @provided_type_static_call ref, + int provided_type: @provided_type_or_none ref +); + +qualified_static_field_expressions( + unique int id: @qualified_static_field_expression +); + +#keyset[id] +qualified_static_field_expression_class_names( + int id: @qualified_static_field_expression ref, + string class_name: string ref +); + +#keyset[id] +qualified_static_field_expression_is_static( + int id: @qualified_static_field_expression ref +); + +#keyset[id] +qualified_static_field_expression_names( + int id: @qualified_static_field_expression ref, + string name: string ref +); + +query_model_elements( + unique int id: @query_model_element +); + +#keyset[id] +query_model_element_allow_cross_company( + int id: @query_model_element ref +); + +#keyset[id] +query_model_element_behaviors( + int id: @query_model_element ref, + int behavior: @class_or_none ref +); + +#keyset[id, index] +query_model_element_data_source_lists( + int id: @query_model_element ref, + int index: int ref, + int data_source_list: @query_data_source_or_none ref +); + +#keyset[id, index] +query_model_element_data_sources( + int id: @query_model_element ref, + int index: int ref, + int data_source: @query_data_source_or_none ref +); + +#keyset[id] +query_model_element_element_type_names( + int id: @query_model_element ref, + string element_type_name: string ref +); + +#keyset[id] +query_model_element_user_update( + int id: @query_model_element ref +); + +@relational_expression = + @equal_expression +| @greater_than_expression +| @greater_than_or_equal_expression +| @less_than_expression +| @less_than_or_equal_expression +| @like_expression +| @not_equal_expression +; + +#keyset[id] +relational_expression_operators( + int id: @relational_expression ref, + string operator: string ref +); + +shift_left_expressions( + unique int id: @shift_left_expression +); + +shift_right_expressions( + unique int id: @shift_right_expression +); + +simple_qualifier_internals( + unique int id: @simple_qualifier_internal +); + +static_qualifiers( + unique int id: @static_qualifier +); + +#keyset[id, index] +static_qualifier_class_type_argument_lists( + int id: @static_qualifier ref, + int index: int ref, + int class_type_argument_list: @xpp_type_or_none ref +); + +string_attribute_literals( + unique int id: @string_attribute_literal +); + +string_length_types( + unique int id: @string_length_type +); + +#keyset[id] +string_length_type_edt_names( + int id: @string_length_type ref, + string edt_name: string ref +); + +#keyset[id] +string_length_type_is_edt( + int id: @string_length_type ref +); + +#keyset[id] +string_length_type_lengths( + int id: @string_length_type ref, + int length: int ref +); + +string_type_internals( + unique int id: @string_type_internal +); + +subtract_expressions( + unique int id: @subtract_expression +); + +sum_aggregate_selections( + unique int id: @sum_aggregate_selection +); + +super_calls( + unique int id: @super_call +); + +tables( + unique int id: @table +); + +#keyset[id] +table_attributes( + int id: @table ref, + int attributes: @attribute_list_or_none ref +); + +#keyset[id] +table_element_type_names( + int id: @table ref, + string element_type_name: string ref +); + +#keyset[id] +table_extends( + int id: @table ref, + string extends: string ref +); + +#keyset[id, index] +table_fields( + int id: @table ref, + int index: int ref, + int field: @field_declaration_or_none ref +); + +#keyset[id, index] +table_indexes( + int id: @table ref, + int index: int ref, + string index: string ref +); + +#keyset[id] +table_is_aggregate_data_entity( + int id: @table ref +); + +#keyset[id] +table_is_data_entity_view( + int id: @table ref +); + +#keyset[id] +table_is_map( + int id: @table ref +); + +#keyset[id] +table_is_updatable( + int id: @table ref +); + +#keyset[id] +table_is_view( + int id: @table ref +); + +#keyset[id] +table_support_inheritance( + int id: @table ref +); + +tts_abort_statements( + unique int id: @tts_abort_statement +); + +tts_begin_statements( + unique int id: @tts_begin_statement +); + +tts_end_statements( + unique int id: @tts_end_statement +); + +unary_minus_expressions( + unique int id: @unary_minus_expression +); + +assign_post_decrement_statements( + unique int id: @assign_post_decrement_statement +); + +assign_post_increment_statements( + unique int id: @assign_post_increment_statement +); + +assign_pre_decrement_statements( + unique int id: @assign_pre_decrement_statement +); + +assign_pre_increment_statements( + unique int id: @assign_pre_increment_statement +); + +@assignment_binary = + @assign_decrement_statement +| @assign_divide_statement +| @assign_equal_statement +| @assign_increment_statement +| @assign_multiply_statement +; + +#keyset[id] +assignment_binary_expressions( + int id: @assignment_binary ref, + int expression: @expression_or_none ref +); + +@assignment_event_handler_base = + @assignment_event_handler_instance +| @assignment_event_handler_static +; + +#keyset[id] +assignment_event_handler_base_addition( + int id: @assignment_event_handler_base ref +); + +#keyset[id] +assignment_event_handler_base_names( + int id: @assignment_event_handler_base ref, + string name: string ref +); + +boolean_literal_expressions( + unique int id: @boolean_literal_expression +); + +classes( + unique int id: @class +); + +#keyset[id, index] +class_fields( + int id: @class ref, + int index: int ref, + int field: @field_declaration_or_none ref +); + +#keyset[id] +class_has_cyclic_inheritance( + int id: @class ref +); + +#keyset[id, index] +class_implements( + int id: @class ref, + int index: int ref, + string implement: string ref +); + +date_literal_expressions( + unique int id: @date_literal_expression +); + +date_time_literal_expressions( + unique int id: @date_time_literal_expression +); + +equal_expressions( + unique int id: @equal_expression +); + +field_declaration_internals( + unique int id: @field_declaration_internal +); + +form_controls( + unique int id: @form_control +); + +#keyset[id] +form_control_auto_declaration( + int id: @form_control ref +); + +#keyset[id, index] +form_control_child_controls( + int id: @form_control ref, + int index: int ref, + int child_control: @form_control_or_none ref +); + +#keyset[id] +form_control_control_classes( + int id: @form_control ref, + string control_class: string ref +); + +#keyset[id] +form_control_control_types( + int id: @form_control ref, + string control_type: string ref +); + +#keyset[id] +form_control_custom_control_classes( + int id: @form_control ref, + string custom_control_class: string ref +); + +#keyset[id] +form_control_element_type_names( + int id: @form_control ref, + string element_type_name: string ref +); + +#keyset[id] +form_control_internal_control_names( + int id: @form_control ref, + string internal_control_name: string ref +); + +#keyset[id] +form_control_is_form_control_extension( + int id: @form_control ref +); + +#keyset[id] +form_control_parent_controls( + int id: @form_control ref, + int parent_control: @form_control_or_none ref +); + +form_data_fields( + unique int id: @form_data_field +); + +#keyset[id] +form_data_field_element_type_names( + int id: @form_data_field ref, + string element_type_name: string ref +); + +#keyset[id] +form_data_field_form_data_sources( + int id: @form_data_field ref, + int form_data_source: @form_data_source_or_none ref +); + +form_data_sources( + unique int id: @form_data_source +); + +#keyset[id, index] +form_data_source_data_fields( + int id: @form_data_source ref, + int index: int ref, + int data_field: @form_data_field_or_none ref +); + +#keyset[id] +form_data_source_element_type_names( + int id: @form_data_source ref, + string element_type_name: string ref +); + +#keyset[id] +form_data_source_join_sources( + int id: @form_data_source ref, + string join_source: string ref +); + +#keyset[id] +form_data_source_link_types( + int id: @form_data_source ref, + string link_type: string ref +); + +#keyset[id] +form_data_source_nested_data_source( + int id: @form_data_source ref +); + +#keyset[id] +form_data_source_queries( + int id: @form_data_source ref, + int query: @query_model_element_or_none ref +); + +#keyset[id] +form_data_source_query_names( + int id: @form_data_source ref, + string query_name: string ref +); + +#keyset[id] +form_data_source_tables( + int id: @form_data_source ref, + string table: string ref +); + +form_element_types( + unique int id: @form_element_type +); + +#keyset[id] +form_element_type_form_names( + int id: @form_element_type ref, + string form_name: string ref +); + +function_calls( + unique int id: @function_call +); + +#keyset[id] +function_call_function_names( + int id: @function_call ref, + string function_name: string ref +); + +function_declarations( + unique int id: @function_declaration +); + +#keyset[id, index] +function_declaration_declarations_and_statements( + int id: @function_declaration ref, + int index: int ref, + int declarations_and_statement: @statement_or_none ref +); + +#keyset[id] +function_declaration_element_type_names( + int id: @function_declaration ref, + string element_type_name: string ref +); + +#keyset[id, index] +function_declaration_locals( + int id: @function_declaration ref, + int index: int ref, + int local: @local_declaration_or_none ref +); + +#keyset[id, index] +function_declaration_parameters( + int id: @function_declaration ref, + int index: int ref, + int parameter: @parameter_declaration_or_none ref +); + +#keyset[id, index] +function_declaration_statements( + int id: @function_declaration ref, + int index: int ref, + int statement: @statement_or_none ref +); + +greater_than_expressions( + unique int id: @greater_than_expression +); + +greater_than_or_equal_expressions( + unique int id: @greater_than_or_equal_expression +); + +int64_literal_expressions( + unique int id: @int64_literal_expression +); + +int_literal_expressions( + unique int id: @int_literal_expression +); + +interfaces( + unique int id: @interface +); + +less_than_expressions( + unique int id: @less_than_expression +); + +less_than_or_equal_expressions( + unique int id: @less_than_or_equal_expression +); + +like_expressions( + unique int id: @like_expression +); + +named_type_internals( + unique int id: @named_type_internal +); + +new_clr_calls( + unique int id: @new_clr_call +); + +#keyset[id] +new_clr_call_clr_class_names( + int id: @new_clr_call ref, + string clr_class_name: string ref +); + +not_equal_expressions( + unique int id: @not_equal_expression +); + +qualified_calls( + unique int id: @qualified_call +); + +#keyset[id] +qualified_call_method_names( + int id: @qualified_call ref, + string method_name: string ref +); + +#keyset[id] +qualified_call_qualifiers( + int id: @qualified_call ref, + int qualifier: @qualifier_or_none ref +); + +qualified_static_calls( + unique int id: @qualified_static_call +); + +#keyset[id] +qualified_static_call_class_names( + int id: @qualified_static_call ref, + string class_name: string ref +); + +#keyset[id, index] +qualified_static_call_class_type_argument_lists( + int id: @qualified_static_call ref, + int index: int ref, + int class_type_argument_list: @xpp_type_or_none ref +); + +#keyset[id] +qualified_static_call_is_table_map_call( + int id: @qualified_static_call ref +); + +#keyset[id] +qualified_static_call_method_names( + int id: @qualified_static_call ref, + string method_name: string ref +); + +#keyset[id] +qualified_static_call_qualifiers( + int id: @qualified_static_call ref, + int qualifier: @qualifier_or_none ref +); + +real_literal_expressions( + unique int id: @real_literal_expression +); + +static_method_calls( + unique int id: @static_method_call +); + +#keyset[id] +static_method_call_class_names( + int id: @static_method_call ref, + string class_name: string ref +); + +#keyset[id, index] +static_method_call_class_type_argument_lists( + int id: @static_method_call ref, + int index: int ref, + int class_type_argument_list: @xpp_type_or_none ref +); + +#keyset[id] +static_method_call_method_names( + int id: @static_method_call ref, + string method_name: string ref +); + +string_literal_expressions( + unique int id: @string_literal_expression +); + +#keyset[id] +string_literal_expression_is_label( + int id: @string_literal_expression ref +); + +#keyset[id] +string_literal_expression_label_file_ids( + int id: @string_literal_expression ref, + string label_file_id: string ref +); + +#keyset[id] +string_literal_expression_label_ids( + int id: @string_literal_expression ref, + string label_id: string ref +); + +table_field_declarations( + unique int id: @table_field_declaration +); + +@variable_declaration = + @parameter_declaration +| @variable_declaration_internal +; + +#keyset[id] +variable_declaration_element_type_names( + int id: @variable_declaration ref, + string element_type_name: string ref +); + +#keyset[id] +variable_declaration_initial_values( + int id: @variable_declaration ref, + int initial_value: @expression_or_none ref +); + +#keyset[id] +variable_declaration_is_const( + int id: @variable_declaration ref +); + +assign_decrement_statements( + unique int id: @assign_decrement_statement +); + +assign_divide_statements( + unique int id: @assign_divide_statement +); + +assign_equal_statements( + unique int id: @assign_equal_statement +); + +assign_increment_statements( + unique int id: @assign_increment_statement +); + +assign_multiply_statements( + unique int id: @assign_multiply_statement +); + +assignment_event_handler_instances( + unique int id: @assignment_event_handler_instance +); + +#keyset[id] +assignment_event_handler_instance_qualifier_parts( + int id: @assignment_event_handler_instance ref, + int qualifier_part: @qualifier_or_none ref +); + +@assignment_event_handler_static = + @assignment_event_handler_clr +| @assignment_event_handler_static_internal +; + +#keyset[id] +assignment_event_handler_static_type_names( + int id: @assignment_event_handler_static ref, + string type_name: string ref +); + +parameter_declarations( + unique int id: @parameter_declaration +); + +#keyset[id] +parameter_declaration_is_by_ref( + int id: @parameter_declaration ref +); + +#keyset[id] +parameter_declaration_is_optional( + int id: @parameter_declaration ref +); + +variable_declaration_internals( + unique int id: @variable_declaration_internal +); + +assignment_event_handler_clrs( + unique int id: @assignment_event_handler_clr +); + +assignment_event_handler_static_internals( + unique int id: @assignment_event_handler_static_internal +); + +@array_specification_or_none = + @array_specification +| @unspecified_element +; + +@attribute_or_none = + @attribute +| @unspecified_element +; + +@attribute_expression_or_none = + @attribute_expression +| @unspecified_element +; + +@attribute_list_or_none = + @attribute_list +| @unspecified_element +; + +@attribute_literal_or_none = + @attribute_literal +| @unspecified_element +; + +@attribute_named_parameter_entry_or_none = + @attribute_named_parameter_entry +| @unspecified_element +; + +@case_or_none = + @case +| @unspecified_element +; + +@catch_or_none = + @catch +| @unspecified_element +; + +@class_or_none = + @class +| @unspecified_element +; + +@class_access_modifier_or_none = + @class_access_modifier +| @unspecified_element +; + +@class_or_interface_or_none = + @class_or_interface +| @unspecified_element +; + +@comment_or_none = + @comment +| @unspecified_element +; + +@compilation_unit_region_entry_or_none = + @compilation_unit_region_entry +| @unspecified_element +; + +@cross_company_or_none = + @cross_company +| @unspecified_element +; + +@evaluation_actual_parameter_entry_or_none = + @evaluation_actual_parameter_entry +| @unspecified_element +; + +@expression_or_none = + @expression +| @unspecified_element +; + +@field_assignment_or_none = + @field_assignment +| @unspecified_element +; + +@field_declaration_or_none = + @field_declaration +| @unspecified_element +; + +@field_specification_or_none = + @field_specification +| @unspecified_element +; + +@file_or_none = + @file +| @unspecified_element +; + +@for_assign_or_none = + @for_assign +| @unspecified_element +; + +@form_control_or_none = + @form_control +| @unspecified_element +; + +@form_data_field_or_none = + @form_data_field +| @unspecified_element +; + +@form_data_source_or_none = + @form_data_source +| @unspecified_element +; + +@form_model_element_or_none = + @form_model_element +| @unspecified_element +; + +@global_order_element_or_none = + @global_order_element +| @unspecified_element +; + +@insert_field_specification_or_none = + @insert_field_specification +| @unspecified_element +; + +@instance_name_or_none = + @instance_name +| @unspecified_element +; + +@join_specification_or_none = + @join_specification +| @unspecified_element +; + +@local_declaration_or_none = + @local_declaration +| @unspecified_element +; + +@location_or_none = + @location +| @unspecified_element +; + +@method_or_delegate_or_none = + @method_or_delegate +| @unspecified_element +; + +@model_element_or_none = + @model_element +| @unspecified_element +; + +@model_element_using_entry_or_none = + @model_element_using_entry +| @unspecified_element +; + +@modifier_or_none = + @modifier +| @unspecified_element +; + +@order_element_or_none = + @order_element +| @unspecified_element +; + +@parameter_declaration_or_none = + @parameter_declaration +| @unspecified_element +; + +@provided_type_or_none = + @provided_type +| @unspecified_element +; + +@qualifier_or_none = + @qualifier +| @unspecified_element +; + +@query_or_none = + @query +| @unspecified_element +; + +@query_data_source_or_none = + @query_data_source +| @unspecified_element +; + +@query_data_source_having_or_none = + @query_data_source_having +| @unspecified_element +; + +@query_data_source_range_or_none = + @query_data_source_range +| @unspecified_element +; + +@query_data_source_relation_or_none = + @query_data_source_relation +| @unspecified_element +; + +@query_model_element_or_none = + @query_model_element +| @unspecified_element +; + +@selection_or_none = + @selection +| @unspecified_element +; + +@selection_field_or_none = + @selection_field +| @unspecified_element +; + +@statement_or_none = + @statement +| @unspecified_element +; + +@switch_statement_case_entry_or_none = + @switch_statement_case_entry +| @unspecified_element +; + +@table_field_reference_or_none = + @table_field_reference +| @unspecified_element +; + +@try_statement_catch_entry_or_none = + @try_statement_catch_entry +| @unspecified_element +; + +@valid_time_state_or_none = + @unspecified_element +| @valid_time_state +; + +@variable_declaration_or_none = + @unspecified_element +| @variable_declaration +; + +@xpp_type_or_none = + @unspecified_element +| @xpp_type +; diff --git a/xpp/ql/lib/xpp.dbscheme.stats b/xpp/ql/lib/xpp.dbscheme.stats new file mode 100644 index 000000000000..9995467e33e5 --- /dev/null +++ b/xpp/ql/lib/xpp.dbscheme.stats @@ -0,0 +1,4 @@ + + + + diff --git a/xpp/ql/test/library-tests/ast/Ast.expected b/xpp/ql/test/library-tests/ast/Ast.expected new file mode 100644 index 000000000000..97b6af7f58a7 --- /dev/null +++ b/xpp/ql/test/library-tests/ast/Ast.expected @@ -0,0 +1,23 @@ +classes +| XppLanguageBasics | +methods +| controlFlow | +| databaseAccess | +statementCounts +| Comment | 10 | +| FieldDeclaration | 2 | +| FindStatement | 1 | +| ForStatement | 1 | +| IfThenElseStatement | 1 | +| ReturnStatement | 1 | +| SearchStatement | 1 | +| SwitchStatement | 1 | +| SwitchStatementCaseEntry | 3 | +| TryStatement | 1 | +| TryStatementCatchEntry | 1 | +| TtsAbortStatement | 1 | +| TtsBeginStatement | 1 | +| TtsEndStatement | 1 | +| WhileStatement | 1 | +searchStatementLine +| 64 | diff --git a/xpp/ql/test/library-tests/ast/Ast.ql b/xpp/ql/test/library-tests/ast/Ast.ql new file mode 100644 index 000000000000..8752cca6c425 --- /dev/null +++ b/xpp/ql/test/library-tests/ast/Ast.ql @@ -0,0 +1,54 @@ +/** + * Checks that the core X++ language constructs are extracted: the class and its methods, the + * control-flow statements, and the database statements that have no equivalent in other + * languages. + */ + +import codeql.xpp.elements + +query predicate classes(string name) { name = any(Class c).getName() } + +query predicate methods(string name) { name = any(Method m).getName() } + +query predicate statementCounts(string kind, int n) { + kind = "ForStatement" and n = count(ForStatement s) + or + kind = "IfThenElseStatement" and n = count(IfThenElseStatement s) + or + kind = "WhileStatement" and n = count(WhileStatement s) + or + kind = "ReturnStatement" and n = count(ReturnStatement s) + or + kind = "SearchStatement" and n = count(SearchStatement s) + or + kind = "FindStatement" and n = count(FindStatement s) + or + kind = "TtsBeginStatement" and n = count(TtsBeginStatement s) + or + kind = "TtsEndStatement" and n = count(TtsEndStatement s) + or + kind = "TtsAbortStatement" and n = count(TtsAbortStatement s) + or + kind = "TryStatement" and n = count(TryStatement s) + or + kind = "SwitchStatement" and n = count(SwitchStatement s) + or + // Switch cases and catch clauses are held in CLR tuples in the compiler's AST, so these + // confirm the extractor looks through tuple slots when walking the tree. + kind = "SwitchStatementCaseEntry" and n = count(SwitchStatementCaseEntry e) + or + kind = "TryStatementCatchEntry" and n = count(TryStatementCatchEntry e) + or + // Class fields live in a dictionary keyed by name in the compiler's AST, so this confirms + // dictionary-held children are reduced to their values rather than to key/value pairs. + kind = "FieldDeclaration" and n = count(FieldDeclaration d) + or + // Comments are struct-typed in the compiler's AST, so they box to a new object on every + // property read. This guards against the reference and the definition getting separate + // labels, which left every comment dangling and failed `codeql dataset check`. + kind = "Comment" and n = count(Comment c) +} + +query predicate searchStatementLine(int line) { + line = any(SearchStatement s).getLocation().getStartLine() +} diff --git a/xpp/ql/test/library-tests/ast/AxClass/XppLanguageBasics.xml b/xpp/ql/test/library-tests/ast/AxClass/XppLanguageBasics.xml new file mode 100644 index 000000000000..707dcbdf7051 --- /dev/null +++ b/xpp/ql/test/library-tests/ast/AxClass/XppLanguageBasics.xml @@ -0,0 +1,88 @@ + + + XppLanguageBasics + + + + + controlFlow + 5) + { + total += i; + } + else + { + total -= i; + } + } + + while (total > 100) + { + total = total div 2; + } + + switch (total) + { + case 0: + total = 1; + break; + + case 1, 2: + total = 3; + break; + + default: + total = -1; + break; + } + + return total; + } +]]> + + + databaseAccess + + + + + diff --git a/xpp/ql/test/qlpack.yml b/xpp/ql/test/qlpack.yml new file mode 100644 index 000000000000..86bf90712efa --- /dev/null +++ b/xpp/ql/test/qlpack.yml @@ -0,0 +1,10 @@ +name: microsoft/xpp-tests +version: 0.0.1 +groups: + - xpp + - test +dependencies: + microsoft/xpp-all: ${workspace} +extractor: xpp +tests: . +warnOnImplicitThis: true diff --git a/xpp/schema/__init__.py b/xpp/schema/__init__.py new file mode 100644 index 000000000000..06723ca0d3f6 --- /dev/null +++ b/xpp/schema/__init__.py @@ -0,0 +1,14 @@ +""" +Schema description + +This file should be kept simple: +* no flow control +* no aliases +* only class definitions with annotations and `include` calls + +For how documentation of generated QL code works, please read +`misc/codegen/schema_documentation.md`. +""" + +from .prelude import * +from .ast import * diff --git a/xpp/schema/ast.py b/xpp/schema/ast.py new file mode 100644 index 000000000000..aa2fb621e840 --- /dev/null +++ b/xpp/schema/ast.py @@ -0,0 +1,1034 @@ +# Generated by xpp/extractor/Xpp.SchemaGenerator, do not edit by hand. +# +# Source: Microsoft.Dynamics.AX.Framework.Xlnt.XppCore.dll +# from Microsoft.Dynamics.AX.Platform.CompilerPackage. +# +# Regenerate with `xpp/tools/generate-schema.sh`. + +from .prelude import * + + +class ArraySpecification(Ast): + index1: optional["Expression"] | child + index2: optional["Expression"] | child + +class Attribute(Ast): + name: optional[string] + named_parameters: list["AttributeNamedParameterEntry"] | child + non_fully_qualified_name: optional[string] + parameters: list["AttributeExpression"] | child + +class AttributeExpression(Ast): + literal: optional["AttributeLiteral"] | child + +class AttributeList(Ast): + attributes: list["Attribute"] | child + contains_internal_use_only_attribute: predicate + +class AttributeLiteral(Ast): + pass + +class AttributeNamedParameterEntry(XppTuple): + item1: optional[string] + attribute_expression: optional["AttributeExpression"] | child + +class Case(Ast): + pass + +class Catch(Ast): + pass + +class ClassAccessModifier(Ast): + class_modifiers: optional[string] + +class CompilationUnit(Ast): + comments: optional["Comment"] | child + is_name_escaped: predicate + name: optional[string] + needs_transformation: predicate + regions: list["CompilationUnitRegionEntry"] | child + +class CompilationUnitRegionEntry(XppTuple): + comment: optional["Comment"] | child + comment2: optional["Comment"] | child + +class CrossCompany(Ast): + pass + +class EvaluationActualParameterEntry(XppTuple): + item1: predicate + expression: optional["Expression"] | child + +class Expression(Ast): + is_const: predicate + transformation: optional["Expression"] | child + +class FieldAssignment(Ast): + expression: optional["Expression"] | child + extension_name: optional[string] + field_name: optional[string] + index: optional[int] + +class FieldSpecification(Ast): + array_index: optional["Expression"] | child + element_type_name: optional[string] + is_const: predicate + is_internal: predicate + is_private: predicate + is_protected: predicate + is_public: predicate + is_read_only: predicate + is_static: predicate + qualifier: optional["Qualifier"] | child + +class ForAssign(Ast): + field_specification: optional["FieldSpecification"] | child + +class InsertFieldSpecification(Ast): + array_index: optional[int] + extension_name: optional[string] + is_extension: predicate + name: optional[string] + +class InstanceName(Ast): + pass + +class JoinSpecification(Ast): + kind: optional[string] + query: optional["Query"] | child + +class ModelElementUsingEntry(XppTuple): + item2: optional[string] + item3: optional[string] + +class Modifier(Ast): + modifiers: optional[string] + +class OrderElement(Ast): + direction: optional[string] + field: optional[string] + index: optional[int] + +class Qualifier(Ast): + pass + +class Query(Ast): + buffer_name: optional[string] + cross_company: optional["CrossCompany"] | child + group_by_elements: list["OrderElement"] | child + index_name: optional[string] + joins: optional["JoinSpecification"] | child + order_by_elements: list["OrderElement"] | child + selection: optional["Selection"] | child + selection_hints: list[string] + uses_hint: predicate + valid_time_state: optional["ValidTimeState"] | child + where: optional["Expression"] | child + +class QueryDataSource(Ast): + data_sources: list["QueryDataSource"] | child + element_type_name: optional[string] + fetch_mode: optional[string] + fields: list[string] + first_fast: predicate + first_only: predicate + group_by: list["GlobalOrderElement"] | child + having: list["QueryDataSourceHaving"] | child | ql.db_table_name("query_data_source_having_prop") + join_mode: optional[string] + name: optional[string] + order_by: list["GlobalOrderElement"] | child + parent_data_source: optional["QueryDataSource"] | child + path_contribution: optional[string] + ranges: list["QueryDataSourceRange"] | child | ql.db_table_name("query_data_source_ranges_prop") + relations: list["QueryDataSourceRelation"] | child | ql.db_table_name("query_data_source_relations_prop") + select_with_repeatable_read: predicate + table: optional[string] + update: predicate + +class QueryDataSourceHaving(Ast): + data_source_name: optional[string] + selection: optional["SelectionField"] | child + value: optional[string] + +class QueryDataSourceRange(Ast): + field: optional[string] + value: optional[string] + +class QueryDataSourceRelation(Ast): + field: optional[string] + join_data_source: optional[string] + related_field: optional[string] + +class Selection(Ast): + pass + +class SelectionField(Ast): + extension_name: optional[string] + field: optional[string] + +class Statement(Ast): + comments: optional[string] + +class SwitchCase(Ast): + pass + +class SwitchStatementCaseEntry(XppTuple): + case: optional["Case"] | child + statements: list["Statement"] | child + +class TableFieldReference(Ast): + index: optional["Expression"] | child + +class TryStatementCatchEntry(XppTuple): + catch: optional["Catch"] | child + statement: optional["Statement"] | child + +class ValidTimeState(Ast): + pass + +class XppType(Ast): + element_type_name: optional[string] + is_obsolete: predicate + +class AggregateSelection(SelectionField): + pass + +class AllFieldsSelection(Selection): + pass + +class AnyType(XppType): + pass + +class AssignmentStatement(Statement): + pass + +class BinaryExpression(Expression): + left: optional["Expression"] | child + right: optional["Expression"] | child + +class BooleanType(XppType): + pass + +class BreakStatement(Statement): + pass + +class BreakpointStatement(Statement): + pass + +class CaseDefault(Case): + pass + +class CaseValues(Case): + values: list["Expression"] | child + +class CatchAllValues(Catch): + pass + +class CatchExpression(Catch): + expression: optional["Expression"] | child + +class CatchUpdateConflict(Catch): + expression: optional["Expression"] | child + instance: optional["InstanceName"] | child + +class ChangeStatement(Statement): + expression: optional["Expression"] | child + statement: optional["Statement"] | child + +class CompoundStatement(Statement): + content: list["Statement"] | child + +class ConditionalExpression(Expression): + condition: optional["Expression"] | child + else_part: optional["Expression"] | child + if_part: optional["Expression"] | child + +class ContainerAttributeLiteral(AttributeLiteral): + value: list["AttributeExpression"] | child + +class ContainerType(XppType): + pass + +class ContinueStatement(Statement): + pass + +class CrossCompanyAll(CrossCompany): + pass + +class CrossCompanyContainer(CrossCompany): + container: optional["Expression"] | child + +class DateTimeType(XppType): + pass + +class DateType(XppType): + pass + +class DblType(XppType): + pass + +class Declaration(CompilationUnit): + array_specification: optional["ArraySpecification"] | child + modifier_list: list["Modifier"] | child + modifiers: optional[string] + type: optional["XppType"] | child + +class DefaultTypeAttributeLiteral(AttributeLiteral): + scanned_literal_value: optional[string] + +class DeleteStatement(Statement): + query: optional["Query"] | child + +class DoWhileStatement(Statement): + condition: optional["Expression"] | child + statement: optional["Statement"] | child + +class EmptyExpression(Expression): + pass + +class EmptyStatement(Statement): + pass + +class EnumAttributeLiteral(AttributeLiteral): + literal: optional[string] + type_name: optional[string] + +class EnumerationType(XppType): + enumerated_type: optional[string] + full_name: optional[string] + namespace: optional[string] + +class Evaluation(Expression): + actual_parameters: list["EvaluationActualParameterEntry"] | child + +class ExplicitSelection(Selection): + fields: list["SelectionField"] | child + +class ExpressionCompilationUnit(CompilationUnit): + expression: optional["Expression"] | child + path_contribution: optional[string] + +class ExpressionQualifier(Qualifier): + expression: optional["Expression"] | child + +class ExpressionStatement(Statement): + element_type_name: optional[string] + expression: optional["Expression"] | child + +class FieldExpression(Expression): + field: optional["FieldSpecification"] | child + is_enum: predicate + +class FieldSelection(SelectionField): + index: optional[int] + +class FindStatement(Statement): + query: optional["Query"] | child + +class FlushStatement(Statement): + id_list: list[string] + +class ForDeclarationAssign(ForAssign): + initialization_declaration: list["VariableDeclaration"] | child + +class ForExpressionAssign(ForAssign): + expression: optional["Expression"] | child + +class ForFieldPostDecrement(ForAssign): + pass + +class ForFieldPostIncrement(ForAssign): + pass + +class ForFieldPreDecrement(ForAssign): + pass + +class ForFieldPreIncrement(ForAssign): + pass + +class ForStatement(Statement): + condition: optional["Expression"] | child + initialization: optional["ForAssign"] | child + statement: optional["Statement"] | child + update: optional["ForAssign"] | child + +class GenericXppType(XppType): + type_argument_list: list["XppType"] | child + +class GlobalOrderElement(OrderElement): + extension_name: optional[string] + table: optional[string] + +class GuidType(XppType): + pass + +class IfStatement(Statement): + condition: optional["Expression"] | child + consequent: optional["Statement"] | child + +class IfThenElseStatement(Statement): + antecedent: optional["Statement"] | child + condition: optional["Expression"] | child + consequent: optional["Statement"] | child + +class ImplicitSelection(Selection): + pass + +class InsertStatement(Statement): + cross_company: optional["CrossCompany"] | child + fields: list["InsertFieldSpecification"] | child + query: optional["Query"] | child + table: optional[string] + +class Int64Type(XppType): + pass + +class IntType(XppType): + pass + +class Intrinsic(Expression): + arg1: optional[string] + arg2: optional[string] + arg3: optional[string] + name: optional[string] + +class IntrinsicAttributeLiteral(AttributeLiteral): + arg1: optional[string] + arg2: optional[string] + arg3: optional[string] + function_name: optional[string] + +class IsAsExpression(Expression): + expression: optional["Expression"] | child + type_name: optional[string] + +class LiteralExpression(Expression): + pass + +class LocalDeclarationsStatement(Statement): + declarations: list["LocalDeclaration"] | child + +class MethodOrDelegate(CompilationUnit): + attributes: optional["AttributeList"] | child + modifier_list: list["Modifier"] | child + parameters: list["ParameterDeclaration"] | child + path_contribution: optional[string] + type: optional["XppType"] | child + type_parameters: list[string] + +class ModelElement(CompilationUnit): + base_methods: list["MethodOrDelegate"] | child + extend_generic_parameters: list["XppType"] | child + full_name: optional[string] + full_name_no_default_namespace: optional[string] + is_internal: predicate + is_kernel: predicate + is_obsolete: predicate + is_private: predicate + is_public: predicate + methods: list["MethodOrDelegate"] | child + model_id: optional[int] + modifier_list: list["ClassAccessModifier"] | child + modifiers: optional[string] + namespace: optional[string] + nested_classes: list["ClassOrInterface"] | child + path_contribution: optional[string] + type_parameters: list[string] + using: list["ModelElementUsingEntry"] | child + visibility: optional[string] + +class MoveCursorStatement(Statement): + selection: optional["Selection"] | child + table: optional[string] + +class NamedFieldReference(TableFieldReference): + extension_name: optional[string] + field_name: optional[string] + +class NewClrArrayExpression(Expression): + full_name: optional[string] + rectangular_dimensions: list[int] + sizes: list["Expression"] | child + type_argument_list: list["XppType"] | child + +class NumberedFieldReference(TableFieldReference): + field_number: optional["Expression"] | child + +class Placeholder(Expression): + pass + +class PrintStatement(Statement): + expressions: list["Expression"] | child + +class ProvidedType(XppType): + argument_list: list["Expression"] | child + name: optional[string] + +class QualifiedField(FieldSpecification): + extension_name: optional[string] + name: optional[string] + +class QualifiedInstanceName(InstanceName): + index: optional["Expression"] | child + name: optional[string] + qualifier: optional["Qualifier"] | child + +class QualifiedNumberedField(FieldSpecification): + field_number: optional["Expression"] | child + +class QualifiedStaticField(FieldSpecification): + class_name: optional[string] + is_enum: predicate + name: optional[string] + +class RetryStatement(Statement): + pass + +class ReturnStatement(Statement): + expression: optional["Expression"] | child + +class SearchStatement(Statement): + query: optional["Query"] | child + statement: optional["Statement"] | child + +class SimpleField(FieldSpecification): + extension_name: optional[string] + is_name_escaped: predicate + name: optional[string] + +class SimpleInstanceName(InstanceName): + index: optional["Expression"] | child + name: optional[string] + +class SimpleOrderElement(OrderElement): + extension_name: optional[string] + +class SimpleQualifier(Qualifier): + name: optional[string] + +class StaticField(FieldSpecification): + class_name: optional[string] + name: optional[string] + +class StringType(XppType): + pass + +class SwitchStatement(Statement): + cases: list["SwitchStatementCaseEntry"] | child + selector: optional["Expression"] | child + +class TableLookupExpression(Expression): + field: optional["TableFieldReference"] | child + query: optional["Query"] | child + +class ThrowStatement(Statement): + exception: optional["Expression"] | child + +class TryStatement(Statement): + catches: list["TryStatementCatchEntry"] | child + finally_: optional["Statement"] | child + statement: optional["Statement"] | child + +class TtsStatement(Statement): + pass + +class UnaryExpression(Expression): + expression: optional["Expression"] | child + +class UncheckedStatement(Statement): + expression: optional["Expression"] | child + statement: optional["Statement"] | child + +class UpdateStatement(Statement): + cross_company: optional["CrossCompany"] | child + field_assignments: list["FieldAssignment"] | child + hints: list[string] + joins: optional["JoinSpecification"] | child + table: optional[string] + where: optional["Expression"] | child + +class UsingStatement(Statement): + disposable_object_initializers: list["VariableDeclaration"] | child + statement: optional["Statement"] | child + +class ValidTimeStateDate(ValidTimeState): + date_variable: optional[string] + +class ValidTimeStateRange(ValidTimeState): + from_date_variable: optional[string] + to_date_variable: optional[string] + +class VarType(XppType): + pass + +class VoidType(XppType): + pass + +class WhileStatement(Statement): + condition: optional["Expression"] | child + statement: optional["Statement"] | child + +class XppTypeCompilationUnit(CompilationUnit): + type: optional["XppType"] | child + +class AddExpression(BinaryExpression): + pass + +class AndExpression(BinaryExpression): + pass + +class AsClrExpression(IsAsExpression): + pass + +class AsExpression(IsAsExpression): + pass + +class AssignMultipleFieldStatement(AssignmentStatement): + expression: optional["Expression"] | child + fields: list["FieldSpecification"] | child + +class AssignmentSingleField(AssignmentStatement): + field: optional["FieldSpecification"] | child + +class AvgAggregateSelection(AggregateSelection): + pass + +class BooleanAttributeLiteral(DefaultTypeAttributeLiteral): + pass + +class ChangeCompanyStatement(ChangeStatement): + pass + +class ClassOrInterface(ModelElement): + attributes: optional["AttributeList"] | child + element_type_name: optional[string] + enclosing_type: optional["ModelElement"] | child + extends: optional[string] + is_abstract: predicate + is_composite_data_entity_view: predicate + is_final: predicate + is_nested: predicate + is_static: predicate + qualifier: optional[string] + +class ClrEnumerationLiteralExpression(LiteralExpression): + enumeration_literal: optional[string] + enumeration_type: optional[string] + +class ClrType(GenericXppType): + full_name: optional[string] + rectangular_dimensions: list[int] + +class ContainerLiteralExpression(LiteralExpression): + value: list["Expression"] | child + +class CountAggregateSelection(AggregateSelection): + pass + +class DateAttributeLiteral(DefaultTypeAttributeLiteral): + pass + +class DateTimeAttributeLiteral(DefaultTypeAttributeLiteral): + pass + +class DblAttributeLiteral(DefaultTypeAttributeLiteral): + pass + +class DefaultTypeLiteralExpression(LiteralExpression): + scanned_literal_value: optional[string] + +class Delegate(MethodOrDelegate): + is_static: predicate + +class DivideExpression(BinaryExpression): + pass + +class EnumerationLiteralExpression(LiteralExpression): + enumeration_literal: optional[string] + enumeration_type: optional[string] + +class FieldDeclaration(Declaration): + attributes: optional["AttributeList"] | child + element_type_name: optional[string] + extension_name: optional[string] + initial_value: optional["Expression"] | child + is_const: predicate + is_extension: predicate + is_internal: predicate + is_obsolete: predicate + is_private: predicate + is_protected: predicate + is_public: predicate + is_read_only: predicate + is_static: predicate + +class FieldExpressionInternal(FieldExpression): + pass + +class ForFieldAssign(ForExpressionAssign): + pass + +class ForFieldDecrementAssign(ForExpressionAssign): + pass + +class ForFieldIncrementAssign(ForExpressionAssign): + pass + +class FormModelElement(ModelElement): + behavior: optional["Class"] | child + controls: list["FormControl"] | child + data_sources: list["FormDataSource"] | child + element_type_name: optional[string] + full_type_name: optional[string] + +class FormNestedElement(ModelElement): + form: optional["FormModelElement"] | child + +class GenericEvaluation(Evaluation): + type_argument_list: list["XppType"] | child + +class GuidAttributeLiteral(DefaultTypeAttributeLiteral): + pass + +class InExpression(BinaryExpression): + pass + +class Int64AttributeLiteral(DefaultTypeAttributeLiteral): + pass + +class IntAttributeLiteral(DefaultTypeAttributeLiteral): + pass + +class IntegerDivideExpression(BinaryExpression): + pass + +class IsClrExpression(IsAsExpression): + pass + +class IsExpression(IsAsExpression): + pass + +class LocalDeclaration(Declaration): + pass + +class MaxAggregateSelection(AggregateSelection): + pass + +class Method(MethodOrDelegate): + declarations_and_statements: list["Statement"] | child + has_local_functions: predicate + is_abstract: predicate + is_client: predicate + is_constructor: predicate + is_display: predicate + is_edit: predicate + is_explicit_non_hookable: predicate + is_explicit_non_wrappable: predicate + is_extended_method: predicate + is_final: predicate + is_hookable: predicate + is_hookable_on_chain_of_command: predicate + is_internal: predicate + is_private: predicate + is_protected: predicate + is_public: predicate + is_replaceable: predicate + is_server: predicate + is_static: predicate + is_type_initializer: predicate + is_wrappable: predicate + locals: list["LocalDeclaration"] | child + modifiers: optional[string] + statements: list["Statement"] | child + +class MinAggregateSelection(AggregateSelection): + pass + +class ModExpression(BinaryExpression): + pass + +class MultiplyExpression(BinaryExpression): + pass + +class NamedType(GenericXppType): + name: optional[string] + +class NewCall(Evaluation): + type: optional["XppType"] | child + +class NextExpression(Evaluation): + name: optional[string] + +class NotExpression(UnaryExpression): + pass + +class NullLiteralExpression(LiteralExpression): + pass + +class OrExpression(BinaryExpression): + pass + +class PhysicalAndExpression(BinaryExpression): + pass + +class PhysicalNotExpression(UnaryExpression): + pass + +class PhysicalOrExpression(BinaryExpression): + pass + +class PhysicalXorExpression(BinaryExpression): + pass + +class ProvidedTypeStaticCall(Evaluation): + method_name: optional[string] + provided_type: optional["ProvidedType"] | child + +class QualifiedStaticFieldExpression(FieldExpression): + class_name: optional[string] + is_static: predicate + name: optional[string] + +class QueryModelElement(ModelElement): + allow_cross_company: predicate + behavior: optional["Class"] | child + data_source_list: list["QueryDataSource"] | child + data_sources: list["QueryDataSource"] | child + element_type_name: optional[string] + user_update: predicate + +class RelationalExpression(BinaryExpression): + operator: optional[string] + +class ShiftLeftExpression(BinaryExpression): + pass + +class ShiftRightExpression(BinaryExpression): + pass + +class SimpleQualifierInternal(SimpleQualifier): + pass + +class StaticQualifier(SimpleQualifier): + class_type_argument_list: list["XppType"] | child + +class StringAttributeLiteral(DefaultTypeAttributeLiteral): + pass + +class StringLengthType(StringType): + edt_name: optional[string] + is_edt: predicate + length: optional[int] + +class StringTypeInternal(StringType): + pass + +class SubtractExpression(BinaryExpression): + pass + +class SumAggregateSelection(AggregateSelection): + pass + +class SuperCall(Evaluation): + pass + +class Table(ModelElement): + attributes: optional["AttributeList"] | child + element_type_name: optional[string] + extends: optional[string] + fields: list["FieldDeclaration"] | child + indexes: list[string] + is_aggregate_data_entity: predicate + is_data_entity_view: predicate + is_map: predicate + is_updatable: predicate + is_view: predicate + support_inheritance: predicate + +class TtsAbortStatement(TtsStatement): + pass + +class TtsBeginStatement(TtsStatement): + pass + +class TtsEndStatement(TtsStatement): + pass + +class UnaryMinusExpression(UnaryExpression): + pass + +class AssignPostDecrementStatement(AssignmentSingleField): + pass + +class AssignPostIncrementStatement(AssignmentSingleField): + pass + +class AssignPreDecrementStatement(AssignmentSingleField): + pass + +class AssignPreIncrementStatement(AssignmentSingleField): + pass + +class AssignmentBinary(AssignmentSingleField): + expression: optional["Expression"] | child + +class AssignmentEventHandlerBase(AssignmentSingleField): + addition: predicate + name: optional[string] + +class BooleanLiteralExpression(DefaultTypeLiteralExpression): + pass + +class Class(ClassOrInterface): + fields: list["FieldDeclaration"] | child + has_cyclic_inheritance: predicate + implements: list[string] + +class DateLiteralExpression(DefaultTypeLiteralExpression): + pass + +class DateTimeLiteralExpression(DefaultTypeLiteralExpression): + pass + +class EqualExpression(RelationalExpression): + pass + +class FieldDeclarationInternal(FieldDeclaration): + pass + +class FormControl(FormNestedElement): + auto_declaration: predicate + child_controls: list["FormControl"] | child + control_class: optional[string] + control_type: optional[string] + custom_control_class: optional[string] + element_type_name: optional[string] + internal_control_name: optional[string] + is_form_control_extension: predicate + parent_control: optional["FormControl"] | child + +class FormDataField(FormNestedElement): + element_type_name: optional[string] + form_data_source: optional["FormDataSource"] | child + +class FormDataSource(FormNestedElement): + data_fields: list["FormDataField"] | child + element_type_name: optional[string] + join_source: optional[string] + link_type: optional[string] + nested_data_source: predicate + query: optional["QueryModelElement"] | child + query_name: optional[string] + table: optional[string] + +class FormElementType(NamedType): + form_name: optional[string] + +class FunctionCall(GenericEvaluation): + function_name: optional[string] + +class FunctionDeclaration(LocalDeclaration): + declarations_and_statements: list["Statement"] | child + element_type_name: optional[string] + locals: list["LocalDeclaration"] | child + parameters: list["ParameterDeclaration"] | child + statements: list["Statement"] | child + +class GreaterThanExpression(RelationalExpression): + pass + +class GreaterThanOrEqualExpression(RelationalExpression): + pass + +class Int64LiteralExpression(DefaultTypeLiteralExpression): + pass + +class IntLiteralExpression(DefaultTypeLiteralExpression): + pass + +class Interface(ClassOrInterface): + pass + +class LessThanExpression(RelationalExpression): + pass + +class LessThanOrEqualExpression(RelationalExpression): + pass + +class LikeExpression(RelationalExpression): + pass + +class NamedTypeInternal(NamedType): + pass + +class NewClrCall(GenericEvaluation): + clr_class_name: optional[string] + +class NotEqualExpression(RelationalExpression): + pass + +class QualifiedCall(GenericEvaluation): + method_name: optional[string] + qualifier: optional["Qualifier"] | child + +class QualifiedStaticCall(GenericEvaluation): + class_name: optional[string] + class_type_argument_list: list["XppType"] | child + is_table_map_call: predicate + method_name: optional[string] + qualifier: optional["Qualifier"] | child + +class RealLiteralExpression(DefaultTypeLiteralExpression): + pass + +class StaticMethodCall(GenericEvaluation): + class_name: optional[string] + class_type_argument_list: list["XppType"] | child + method_name: optional[string] + +class StringLiteralExpression(DefaultTypeLiteralExpression): + is_label: predicate + label_file_id: optional[string] + label_id: optional[string] + +class TableFieldDeclaration(FieldDeclaration): + pass + +class VariableDeclaration(LocalDeclaration): + element_type_name: optional[string] + initial_value: optional["Expression"] | child + is_const: predicate + +class AssignDecrementStatement(AssignmentBinary): + pass + +class AssignDivideStatement(AssignmentBinary): + pass + +class AssignEqualStatement(AssignmentBinary): + pass + +class AssignIncrementStatement(AssignmentBinary): + pass + +class AssignMultiplyStatement(AssignmentBinary): + pass + +class AssignmentEventHandlerInstance(AssignmentEventHandlerBase): + qualifier_part: optional["Qualifier"] | child + +class AssignmentEventHandlerStatic(AssignmentEventHandlerBase): + type_name: optional[string] + +class ParameterDeclaration(VariableDeclaration): + is_by_ref: predicate + is_optional: predicate + +class VariableDeclarationInternal(VariableDeclaration): + pass + +class AssignmentEventHandlerClr(AssignmentEventHandlerStatic): + pass + +class AssignmentEventHandlerStaticInternal(AssignmentEventHandlerStatic): + pass diff --git a/xpp/schema/prelude.py b/xpp/schema/prelude.py new file mode 100644 index 000000000000..3328da1060c9 --- /dev/null +++ b/xpp/schema/prelude.py @@ -0,0 +1,85 @@ +""" +Hand-written base of the X++ schema. + +`ast.py` is generated from the X++ compiler's own AST hierarchy and layers on top of the +classes defined here. Keep this file simple: only class definitions with annotations and +`include` calls. +""" + +from misc.codegen.lib.schemadefs import * + +include("prefix.dbscheme") + + +@qltest.skip +class Element: + is_unknown: predicate + + +@qltest.collapse_hierarchy +class File(Element): + name: string + + +@qltest.skip +@qltest.collapse_hierarchy +class Location(Element): + file: File + start_line: int + start_column: int + end_line: int + end_column: int + + +@qltest.skip +class Locatable(Element): + location: optional[Location] | doc("location associated with this element in the code") + + +@qltest.skip +@qltest.collapse_hierarchy +class ErrorElement(Locatable): + """The superclass of all elements indicating some kind of error.""" + + pass + + +@use_for_null +class UnspecifiedElement(ErrorElement): + """A node that could not be extracted, for example because of a syntax error.""" + + parent: optional[Element] + property: string + index: optional[int] + error: string + + +class Comment(Locatable): + """A comment in X++ source.""" + + text: optional[string] + + +@qltest.skip +class Ast(Locatable): + """ + Root of the X++ abstract syntax tree. + + This mirrors `Microsoft.Dynamics.AX.Metadata.XppCompiler.Ast`, the base class of the + X++ compiler's own AST. + """ + + pass + + +@qltest.skip +class XppTuple(Locatable): + """ + Base of the classes standing in for tuples in the compiler's AST. + + The X++ compiler uses CLR tuples for a handful of grouped values, such as a `catch` + together with its handler body. The schema has no tuple type, so the generator emits a + named class per tuple-valued property instead. + """ + + pass diff --git a/xpp/tools/autobuild.cmd b/xpp/tools/autobuild.cmd new file mode 100644 index 000000000000..2605035be083 --- /dev/null +++ b/xpp/tools/autobuild.cmd @@ -0,0 +1,3 @@ +@echo off +rem X++ is extracted from source with no build step. +"%CODEQL_EXTRACTOR_XPP_ROOT%\tools\%CODEQL_PLATFORM%\Xpp.Extractor.exe" . diff --git a/xpp/tools/autobuild.sh b/xpp/tools/autobuild.sh new file mode 100755 index 000000000000..e5945e40241a --- /dev/null +++ b/xpp/tools/autobuild.sh @@ -0,0 +1,6 @@ +#!/bin/bash +set -eu + +# X++ is extracted from source with no build step: walk the source root for metadata objects +# that carry X++ and extract them. +exec "$CODEQL_EXTRACTOR_XPP_ROOT/tools/$CODEQL_PLATFORM/Xpp.Extractor" . diff --git a/xpp/tools/build-extractor-pack.sh b/xpp/tools/build-extractor-pack.sh new file mode 100755 index 000000000000..fb14bfd8fdbb --- /dev/null +++ b/xpp/tools/build-extractor-pack.sh @@ -0,0 +1,73 @@ +#!/bin/bash +# Assembles the X++ extractor pack. +# +# xpp/tools/build-extractor-pack.sh [output-dir] +# +# Produces a directory the CodeQL CLI can use via `--search-path`, laid out as the CLI expects: +# +# /xpp/codeql-extractor.yml +# /xpp/xpp.dbscheme(.stats) +# /xpp/tools/{index-files,autobuild,qltest}.{sh,cmd} +# /xpp/tools//Xpp.Extractor +# +# The proprietary compiler package is not bundled; the extractor resolves it at run time from +# XPP_COMPILER_PACKAGE. + +set -euo pipefail + +here="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" +xpp_root="$(dirname "$here")" +output="${1:-$xpp_root/extractor-pack}" + +case "$(uname -s)" in + Darwin) platform="osx64" ;; + Linux) platform="linux64" ;; + *) platform="win64" ;; +esac + +pack="$output/xpp" + +# Resolve $pack without requiring it to exist yet, so it can be compared with the source tree. +pack_parent="$(cd "$(dirname "$pack")" 2>/dev/null && pwd || true)" +if [ -z "$pack_parent" ]; then + echo "output directory does not exist: $(dirname "$pack")" >&2 + exit 2 +fi +pack_abs="$pack_parent/$(basename "$pack")" +xpp_abs="$(cd "$xpp_root" && pwd)" + +# Passing the repository root would make $pack the source tree itself, and the removal below +# would delete it. +if [ "$pack_abs" = "$xpp_abs" ]; then + echo "refusing to build into the source tree: $pack_abs" >&2 + exit 2 +fi + +if [ -e "$pack_abs" ]; then + # Only ever remove something that is itself a previously built pack. + if [ ! -f "$pack_abs/codeql-extractor.yml" ]; then + echo "refusing to remove $pack_abs: it is not a generated extractor pack" >&2 + exit 2 + fi + rm -rf "$pack_abs" +fi + +pack="$pack_abs" +mkdir -p "$pack/tools/$platform" + +cp "$xpp_root/codeql-extractor.yml" "$pack/" +cp "$xpp_root/ql/lib/xpp.dbscheme" "$pack/" +cp "$xpp_root/ql/lib/xpp.dbscheme.stats" "$pack/" + +for script in index-files autobuild qltest; do + cp "$here/$script.sh" "$here/$script.cmd" "$pack/tools/" +done +chmod +x "$pack/tools/"*.sh + +dotnet publish "$xpp_root/extractor/Xpp.Extractor" \ + -c Release \ + -o "$pack/tools/$platform" \ + --nologo \ + -v quiet + +echo "extractor pack written to $pack" diff --git a/xpp/tools/generate-schema.sh b/xpp/tools/generate-schema.sh new file mode 100755 index 000000000000..e13f8ebef434 --- /dev/null +++ b/xpp/tools/generate-schema.sh @@ -0,0 +1,44 @@ +#!/bin/bash +# Regenerates the X++ schema, dbscheme and QL classes. +# +# The schema is derived by reflection from the X++ compiler's own AST hierarchy in +# Microsoft.Dynamics.AX.Framework.Xlnt.XppCore.dll, which ships in the proprietary +# Microsoft.Dynamics.AX.Platform.CompilerPackage. That package is not committed here, so point +# XPP_COMPILER_PACKAGE at an extracted copy: +# +# XPP_COMPILER_PACKAGE=/path/to/extracted/nupkg xpp/tools/generate-schema.sh +# +# The generated schema, dbscheme and QL are committed, so this is only needed when moving to a +# new platform release. + +set -euo pipefail + +here="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)" +xpp_root="$(dirname "$here")" +repo_root="$(dirname "$xpp_root")" + +if [ -z "${XPP_COMPILER_PACKAGE:-}" ]; then + echo "XPP_COMPILER_PACKAGE is not set." >&2 + echo "Point it at an extracted Microsoft.Dynamics.AX.Platform.CompilerPackage." >&2 + exit 2 +fi + +PYTHON="${PYTHON:-python3}" + +echo "==> generating schema/ast.py from $XPP_COMPILER_PACKAGE" +dotnet run --project "$xpp_root/extractor/Xpp.SchemaGenerator" -c Release -- \ + schema \ + --package "$XPP_COMPILER_PACKAGE" \ + --output "$xpp_root/schema/ast.py" + +echo "==> running misc/codegen" +cd "$xpp_root" +PYTHONPATH="$repo_root" "$PYTHON" "$repo_root/misc/codegen/codegen.py" + +echo "==> generating the TRAP writer" +dotnet run --project "$xpp_root/extractor/Xpp.SchemaGenerator" -c Release -- \ + trap "$xpp_root/ql/lib/xpp.dbscheme" \ + --package "$XPP_COMPILER_PACKAGE" \ + --output "$xpp_root/extractor/Xpp.Extraction/Generated/AstTrapEmitter.g.cs" + +echo "==> done" diff --git a/xpp/tools/index-files.cmd b/xpp/tools/index-files.cmd new file mode 100644 index 000000000000..1a03e78f19ab --- /dev/null +++ b/xpp/tools/index-files.cmd @@ -0,0 +1,2 @@ +@echo off +"%CODEQL_EXTRACTOR_XPP_ROOT%\tools\%CODEQL_PLATFORM%\Xpp.Extractor.exe" --file-list "%1" diff --git a/xpp/tools/index-files.sh b/xpp/tools/index-files.sh new file mode 100755 index 000000000000..9ffa91da9494 --- /dev/null +++ b/xpp/tools/index-files.sh @@ -0,0 +1,4 @@ +#!/bin/bash +set -eu + +exec "$CODEQL_EXTRACTOR_XPP_ROOT/tools/$CODEQL_PLATFORM/Xpp.Extractor" --file-list "$1" diff --git a/xpp/tools/qltest.cmd b/xpp/tools/qltest.cmd new file mode 100644 index 000000000000..9fb0791374b0 --- /dev/null +++ b/xpp/tools/qltest.cmd @@ -0,0 +1,2 @@ +@echo off +"%CODEQL_EXTRACTOR_XPP_ROOT%\tools\%CODEQL_PLATFORM%\Xpp.Extractor.exe" . diff --git a/xpp/tools/qltest.sh b/xpp/tools/qltest.sh new file mode 100755 index 000000000000..2df91fe8aad1 --- /dev/null +++ b/xpp/tools/qltest.sh @@ -0,0 +1,4 @@ +#!/bin/bash +set -eu + +exec "$CODEQL_EXTRACTOR_XPP_ROOT/tools/$CODEQL_PLATFORM/Xpp.Extractor" .