Ruby: use consistent capitalization with import ... as

ruby/ql/lib/codeql/ruby/ast/internal/AST.qll

@@ -4,7 +4,7 @@ private import codeql.ruby.ast.internal.Call
 private import codeql.ruby.ast.internal.Parameter
 private import codeql.ruby.ast.internal.Pattern
 private import codeql.ruby.ast.internal.Variable
-private import codeql.ruby.AST as AST
+private import codeql.ruby.AST as Ast
 private import Synthesis
 
 module MethodName {
@@ -20,7 +20,7 @@ module MethodName {
         @ruby_token_operator;
 }
 
-private predicate mkSynthChild(SynthKind kind, AST::AstNode parent, int i) {
+private predicate mkSynthChild(SynthKind kind, Ast::AstNode parent, int i) {
   any(Synthesis s).child(parent, i, SynthChild(kind))
 }
 
@@ -29,7 +29,7 @@ private module Cached {
   cached
   newtype TAstNode =
     TAddExprReal(Ruby::Binary g) { g instanceof @ruby_binary_plus } or
-    TAddExprSynth(AST::AstNode parent, int i) { mkSynthChild(AddExprKind(), parent, i) } or
+    TAddExprSynth(Ast::AstNode parent, int i) { mkSynthChild(AddExprKind(), parent, i) } or
     TAliasStmt(Ruby::Alias g) or
     TAlternativePattern(Ruby::AlternativePattern g) or
     TArgumentList(Ruby::AstNode g) {
@@ -62,7 +62,7 @@ private module Cached {
       g instanceof @ruby_operator_assignment_starstarequal
     } or
     TAssignExprReal(Ruby::Assignment g) or
-    TAssignExprSynth(AST::AstNode parent, int i) { mkSynthChild(AssignExprKind(), parent, i) } or
+    TAssignExprSynth(Ast::AstNode parent, int i) { mkSynthChild(AssignExprKind(), parent, i) } or
     TAssignLShiftExpr(Ruby::OperatorAssignment g) {
       g instanceof @ruby_operator_assignment_langlelangleequal
     } or
@@ -86,34 +86,34 @@ private module Cached {
     TBeginBlock(Ruby::BeginBlock g) or
     TBeginExpr(Ruby::Begin g) or
     TBitwiseAndExprReal(Ruby::Binary g) { g instanceof @ruby_binary_ampersand } or
-    TBitwiseAndExprSynth(AST::AstNode parent, int i) {
+    TBitwiseAndExprSynth(Ast::AstNode parent, int i) {
       mkSynthChild(BitwiseAndExprKind(), parent, i)
     } or
     TBitwiseOrExprReal(Ruby::Binary g) { g instanceof @ruby_binary_pipe } or
-    TBitwiseOrExprSynth(AST::AstNode parent, int i) { mkSynthChild(BitwiseOrExprKind(), parent, i) } or
+    TBitwiseOrExprSynth(Ast::AstNode parent, int i) { mkSynthChild(BitwiseOrExprKind(), parent, i) } or
     TBitwiseXorExprReal(Ruby::Binary g) { g instanceof @ruby_binary_caret } or
-    TBitwiseXorExprSynth(AST::AstNode parent, int i) {
+    TBitwiseXorExprSynth(Ast::AstNode parent, int i) {
       mkSynthChild(BitwiseXorExprKind(), parent, i)
     } or
     TBlockArgument(Ruby::BlockArgument g) or
     TBlockParameter(Ruby::BlockParameter g) or
-    TBraceBlockSynth(AST::AstNode parent, int i) { mkSynthChild(BraceBlockKind(), parent, i) } or
+    TBraceBlockSynth(Ast::AstNode parent, int i) { mkSynthChild(BraceBlockKind(), parent, i) } or
     TBraceBlockReal(Ruby::Block g) { not g.getParent() instanceof Ruby::Lambda } or
     TBreakStmt(Ruby::Break g) or
     TCaseEqExpr(Ruby::Binary g) { g instanceof @ruby_binary_equalequalequal } or
     TCaseExpr(Ruby::Case g) or
     TCaseMatch(Ruby::CaseMatch g) or
     TCharacterLiteral(Ruby::Character g) or
     TClassDeclaration(Ruby::Class g) or
-    TClassVariableAccessReal(Ruby::ClassVariable g, AST::ClassVariable v) {
+    TClassVariableAccessReal(Ruby::ClassVariable g, Ast::ClassVariable v) {
       ClassVariableAccess::range(g, v)
     } or
-    TClassVariableAccessSynth(AST::AstNode parent, int i, AST::ClassVariable v) {
+    TClassVariableAccessSynth(Ast::AstNode parent, int i, Ast::ClassVariable v) {
       mkSynthChild(ClassVariableAccessKind(v), parent, i)
     } or
     TComplementExpr(Ruby::Unary g) { g instanceof @ruby_unary_tilde } or
     TComplexLiteral(Ruby::Complex g) or
-    TConstantReadAccessSynth(AST::AstNode parent, int i, string value) {
+    TConstantReadAccessSynth(Ast::AstNode parent, int i, string value) {
       mkSynthChild(ConstantReadAccessKind(value), parent, i)
     } or
     TDefinedExpr(Ruby::Unary g) { g instanceof @ruby_unary_definedquestion } or
@@ -122,7 +122,7 @@ private module Cached {
       not strictcount(int i | exists(g.getParent().(Ruby::LeftAssignmentList).getChild(i))) = 1
     } or
     TDivExprReal(Ruby::Binary g) { g instanceof @ruby_binary_slash } or
-    TDivExprSynth(AST::AstNode parent, int i) { mkSynthChild(DivExprKind(), parent, i) } or
+    TDivExprSynth(Ast::AstNode parent, int i) { mkSynthChild(DivExprKind(), parent, i) } or
     TDo(Ruby::Do g) or
     TDoBlock(Ruby::DoBlock g) { not g.getParent() instanceof Ruby::Lambda } or
     TElementReference(Ruby::ElementReference g) or
@@ -134,7 +134,7 @@ private module Cached {
     TEnsure(Ruby::Ensure g) or
     TEqExpr(Ruby::Binary g) { g instanceof @ruby_binary_equalequal } or
     TExponentExprReal(Ruby::Binary g) { g instanceof @ruby_binary_starstar } or
-    TExponentExprSynth(AST::AstNode parent, int i) { mkSynthChild(ExponentExprKind(), parent, i) } or
+    TExponentExprSynth(Ast::AstNode parent, int i) { mkSynthChild(ExponentExprKind(), parent, i) } or
     TFalseLiteral(Ruby::False g) or
     TFile(Ruby::File g) or
     TFindPattern(Ruby::FindPattern g) or
@@ -146,10 +146,10 @@ private module Cached {
     TForwardArgument(Ruby::ForwardArgument g) or
     TGEExpr(Ruby::Binary g) { g instanceof @ruby_binary_rangleequal } or
     TGTExpr(Ruby::Binary g) { g instanceof @ruby_binary_rangle } or
-    TGlobalVariableAccessReal(Ruby::GlobalVariable g, AST::GlobalVariable v) {
+    TGlobalVariableAccessReal(Ruby::GlobalVariable g, Ast::GlobalVariable v) {
       GlobalVariableAccess::range(g, v)
     } or
-    TGlobalVariableAccessSynth(AST::AstNode parent, int i, AST::GlobalVariable v) {
+    TGlobalVariableAccessSynth(Ast::AstNode parent, int i, Ast::GlobalVariable v) {
       mkSynthChild(GlobalVariableAccessKind(v), parent, i)
     } or
     THashKeySymbolLiteral(Ruby::HashKeySymbol g) or
@@ -163,70 +163,70 @@ private module Cached {
     THereDoc(Ruby::HeredocBeginning g) or
     TIdentifierMethodCall(Ruby::Identifier g) { isIdentifierMethodCall(g) } or
     TIfReal(Ruby::If g) or
-    TIfSynth(AST::AstNode parent, int i) { mkSynthChild(IfKind(), parent, i) } or
+    TIfSynth(Ast::AstNode parent, int i) { mkSynthChild(IfKind(), parent, i) } or
     TIfModifierExpr(Ruby::IfModifier g) or
     TInClause(Ruby::InClause g) or
-    TInstanceVariableAccessReal(Ruby::InstanceVariable g, AST::InstanceVariable v) {
+    TInstanceVariableAccessReal(Ruby::InstanceVariable g, Ast::InstanceVariable v) {
       InstanceVariableAccess::range(g, v)
     } or
-    TInstanceVariableAccessSynth(AST::AstNode parent, int i, AST::InstanceVariable v) {
+    TInstanceVariableAccessSynth(Ast::AstNode parent, int i, Ast::InstanceVariable v) {
       mkSynthChild(InstanceVariableAccessKind(v), parent, i)
     } or
     TIntegerLiteralReal(Ruby::Integer g) {
       not any(Ruby::Complex r).getChild() = g and not any(Ruby::Rational r).getChild() = g
     } or
-    TIntegerLiteralSynth(AST::AstNode parent, int i, int value) {
+    TIntegerLiteralSynth(Ast::AstNode parent, int i, int value) {
       mkSynthChild(IntegerLiteralKind(value), parent, i)
     } or
     TKeywordParameter(Ruby::KeywordParameter g) or
     TLEExpr(Ruby::Binary g) { g instanceof @ruby_binary_langleequal } or
     TLShiftExprReal(Ruby::Binary g) { g instanceof @ruby_binary_langlelangle } or
-    TLShiftExprSynth(AST::AstNode parent, int i) { mkSynthChild(LShiftExprKind(), parent, i) } or
+    TLShiftExprSynth(Ast::AstNode parent, int i) { mkSynthChild(LShiftExprKind(), parent, i) } or
     TLTExpr(Ruby::Binary g) { g instanceof @ruby_binary_langle } or
     TLambda(Ruby::Lambda g) or
     TLine(Ruby::Line g) or
     TLeftAssignmentList(Ruby::LeftAssignmentList g) or
     TLocalVariableAccessReal(Ruby::Identifier g, TLocalVariableReal v) {
       LocalVariableAccess::range(g, v)
     } or
-    TLocalVariableAccessSynth(AST::AstNode parent, int i, AST::LocalVariable v) {
+    TLocalVariableAccessSynth(Ast::AstNode parent, int i, Ast::LocalVariable v) {
       mkSynthChild(LocalVariableAccessRealKind(v), parent, i)
       or
       mkSynthChild(LocalVariableAccessSynthKind(v), parent, i)
     } or
     TLogicalAndExprReal(Ruby::Binary g) {
       g instanceof @ruby_binary_and or g instanceof @ruby_binary_ampersandampersand
     } or
-    TLogicalAndExprSynth(AST::AstNode parent, int i) {
+    TLogicalAndExprSynth(Ast::AstNode parent, int i) {
       mkSynthChild(LogicalAndExprKind(), parent, i)
     } or
     TLogicalOrExprReal(Ruby::Binary g) {
       g instanceof @ruby_binary_or or g instanceof @ruby_binary_pipepipe
     } or
-    TLogicalOrExprSynth(AST::AstNode parent, int i) { mkSynthChild(LogicalOrExprKind(), parent, i) } or
+    TLogicalOrExprSynth(Ast::AstNode parent, int i) { mkSynthChild(LogicalOrExprKind(), parent, i) } or
     TMethod(Ruby::Method g) or
-    TMethodCallSynth(AST::AstNode parent, int i, string name, boolean setter, int arity) {
+    TMethodCallSynth(Ast::AstNode parent, int i, string name, boolean setter, int arity) {
       mkSynthChild(MethodCallKind(name, setter, arity), parent, i)
     } or
     TModuleDeclaration(Ruby::Module g) or
     TModuloExprReal(Ruby::Binary g) { g instanceof @ruby_binary_percent } or
-    TModuloExprSynth(AST::AstNode parent, int i) { mkSynthChild(ModuloExprKind(), parent, i) } or
+    TModuloExprSynth(Ast::AstNode parent, int i) { mkSynthChild(ModuloExprKind(), parent, i) } or
     TMulExprReal(Ruby::Binary g) { g instanceof @ruby_binary_star } or
-    TMulExprSynth(AST::AstNode parent, int i) { mkSynthChild(MulExprKind(), parent, i) } or
+    TMulExprSynth(Ast::AstNode parent, int i) { mkSynthChild(MulExprKind(), parent, i) } or
     TNEExpr(Ruby::Binary g) { g instanceof @ruby_binary_bangequal } or
     TNextStmt(Ruby::Next g) or
     TNilLiteralReal(Ruby::Nil g) or
-    TNilLiteralSynth(AST::AstNode parent, int i) { mkSynthChild(NilLiteralKind(), parent, i) } or
+    TNilLiteralSynth(Ast::AstNode parent, int i) { mkSynthChild(NilLiteralKind(), parent, i) } or
     TNoRegExpMatchExpr(Ruby::Binary g) { g instanceof @ruby_binary_bangtilde } or
     TNotExpr(Ruby::Unary g) { g instanceof @ruby_unary_bang or g instanceof @ruby_unary_not } or
     TOptionalParameter(Ruby::OptionalParameter g) or
     TPair(Ruby::Pair g) or
     TParenthesizedExpr(Ruby::ParenthesizedStatements g) or
     TParenthesizedPattern(Ruby::ParenthesizedPattern g) or
     TRShiftExprReal(Ruby::Binary g) { g instanceof @ruby_binary_ranglerangle } or
-    TRShiftExprSynth(AST::AstNode parent, int i) { mkSynthChild(RShiftExprKind(), parent, i) } or
+    TRShiftExprSynth(Ast::AstNode parent, int i) { mkSynthChild(RShiftExprKind(), parent, i) } or
     TRangeLiteralReal(Ruby::Range g) or
-    TRangeLiteralSynth(AST::AstNode parent, int i, boolean inclusive) {
+    TRangeLiteralSynth(Ast::AstNode parent, int i, boolean inclusive) {
       mkSynthChild(RangeLiteralKind(inclusive), parent, i)
     } or
     TRationalLiteral(Ruby::Rational g) { not any(Ruby::Complex r).getChild() = g } or
@@ -255,24 +255,24 @@ private module Cached {
       )
     } or
     TSelfReal(Ruby::Self g) or
-    TSelfSynth(AST::AstNode parent, int i, AST::SelfVariable v) {
+    TSelfSynth(Ast::AstNode parent, int i, Ast::SelfVariable v) {
       mkSynthChild(SelfKind(v), parent, i)
     } or
     TSimpleParameterReal(Ruby::Identifier g) { g instanceof Parameter::Range } or
-    TSimpleParameterSynth(AST::AstNode parent, int i) {
+    TSimpleParameterSynth(Ast::AstNode parent, int i) {
       mkSynthChild(SimpleParameterKind(), parent, i)
     } or
     TSimpleSymbolLiteral(Ruby::SimpleSymbol g) or
     TSingletonClass(Ruby::SingletonClass g) or
     TSingletonMethod(Ruby::SingletonMethod g) or
     TSpaceshipExpr(Ruby::Binary g) { g instanceof @ruby_binary_langleequalrangle } or
     TSplatExprReal(Ruby::SplatArgument g) or
-    TSplatExprSynth(AST::AstNode parent, int i) { mkSynthChild(SplatExprKind(), parent, i) } or
+    TSplatExprSynth(Ast::AstNode parent, int i) { mkSynthChild(SplatExprKind(), parent, i) } or
     TSplatParameter(Ruby::SplatParameter g) {
       not g.getParent() instanceof Ruby::ArrayPattern and
       not g.getParent() instanceof Ruby::FindPattern
     } or
-    TStmtSequenceSynth(AST::AstNode parent, int i) { mkSynthChild(StmtSequenceKind(), parent, i) } or
+    TStmtSequenceSynth(Ast::AstNode parent, int i) { mkSynthChild(StmtSequenceKind(), parent, i) } or
     TStringArrayLiteral(Ruby::StringArray g) or
     TStringConcatenation(Ruby::ChainedString g) or
     TStringEscapeSequenceComponentNonRegexp(Ruby::EscapeSequence g) {
@@ -298,7 +298,7 @@ private module Cached {
       g.getParent() instanceof Ruby::Regex
     } or
     TSubExprReal(Ruby::Binary g) { g instanceof @ruby_binary_minus } or
-    TSubExprSynth(AST::AstNode parent, int i) { mkSynthChild(SubExprKind(), parent, i) } or
+    TSubExprSynth(Ast::AstNode parent, int i) { mkSynthChild(SubExprKind(), parent, i) } or
     TSubshellLiteral(Ruby::Subshell g) or
     TSymbolArrayLiteral(Ruby::SymbolArray g) or
     TTernaryIfExpr(Ruby::Conditional g) or
@@ -548,7 +548,7 @@ private module Cached {
 
   /** Gets the `i`th synthesized child of `parent`. */
   cached
-  AST::AstNode getSynthChild(AST::AstNode parent, int i) {
+  Ast::AstNode getSynthChild(Ast::AstNode parent, int i) {
     result = TAddExprSynth(parent, i)
     or
     result = TAssignExprSynth(parent, i)
@@ -613,7 +613,7 @@ private module Cached {
    * `child` (or both) is a synthesized node.
    */
   cached
-  predicate synthChild(AST::AstNode parent, int i, AST::AstNode child) {
+  predicate synthChild(Ast::AstNode parent, int i, Ast::AstNode child) {
     child = getSynthChild(parent, i)
     or
     any(Synthesis s).child(parent, i, RealChildRef(child))
@@ -626,18 +626,18 @@ private module Cached {
    * nodes.
    */
   cached
-  Ruby::AstNode toGeneratedInclSynth(AST::AstNode n) {
+  Ruby::AstNode toGeneratedInclSynth(Ast::AstNode n) {
     result = toGenerated(n)
     or
     not exists(toGenerated(n)) and
-    exists(AST::AstNode parent |
+    exists(Ast::AstNode parent |
       synthChild(parent, _, n) and
       result = toGeneratedInclSynth(parent)
     )
   }
 
   cached
-  Location getLocation(AST::AstNode n) {
+  Location getLocation(Ast::AstNode n) {
     synthLocation(n, result)
     or
     n.isSynthesized() and
@@ -648,12 +648,12 @@ private module Cached {
   }
 
   cached
-  predicate lhsExpr(AST::Expr e) {
+  predicate lhsExpr(Ast::Expr e) {
     explicitAssignmentNode(toGenerated(e), _)
     or
     implicitAssignmentNode(toGenerated(e))
     or
-    e = getSynthChild(any(AST::AssignExpr ae), 0)
+    e = getSynthChild(any(Ast::AssignExpr ae), 0)
   }
 }
 

ruby/ql/lib/codeql/ruby/controlflow/internal/ControlFlowGraphImplSpecific.qll

@@ -3,7 +3,7 @@ private import ControlFlowGraphImpl as Impl
 private import Completion as Comp
 private import codeql.ruby.ast.internal.Synthesis
 private import Splitting as Splitting
-private import codeql.ruby.CFG as CFG
+private import codeql.ruby.CFG as Cfg
 
 /** The base class for `ControlFlowTree`. */
 class ControlFlowTreeBase extends RB::AstNode {
@@ -29,7 +29,7 @@ predicate completionIsSimple(Completion c) { c instanceof Comp::SimpleCompletion
 /** Holds if `c` is a valid completion for `e`. */
 predicate completionIsValidFor(Completion c, ControlFlowElement e) { c.isValidFor(e) }
 
-class CfgScope = CFG::CfgScope;
+class CfgScope = Cfg::CfgScope;
 
 predicate getCfgScope = Impl::getCfgScope/1;
 
@@ -50,7 +50,7 @@ class SplitKindBase = Splitting::TSplitKind;
 
 class Split = Splitting::Split;
 
-class SuccessorType = CFG::SuccessorType;
+class SuccessorType = Cfg::SuccessorType;
 
 /** Gets a successor type that matches completion `c`. */
 SuccessorType getAMatchingSuccessorType(Completion c) { result = c.getAMatchingSuccessorType() }
@@ -60,15 +60,15 @@ SuccessorType getAMatchingSuccessorType(Completion c) { result = c.getAMatchingS
  * expression.
  */
 predicate successorTypeIsSimple(SuccessorType t) {
-  t instanceof CFG::SuccessorTypes::NormalSuccessor
+  t instanceof Cfg::SuccessorTypes::NormalSuccessor
 }
 
 /** Holds if `t` is an abnormal exit type out of a CFG scope. */
 predicate isAbnormalExitType(SuccessorType t) {
-  t instanceof CFG::SuccessorTypes::RaiseSuccessor or
-  t instanceof CFG::SuccessorTypes::ExitSuccessor
+  t instanceof Cfg::SuccessorTypes::RaiseSuccessor or
+  t instanceof Cfg::SuccessorTypes::ExitSuccessor
 }
 
 class Location = RB::Location;
 
-class Node = CFG::CfgNode;
+class Node = Cfg::CfgNode;