diff --git a/actions/ql/lib/codeql/actions/controlflow/internal/Cfg.qll b/actions/ql/lib/codeql/actions/controlflow/internal/Cfg.qll index 76187d860b4..38ce9e7e03d 100644 --- a/actions/ql/lib/codeql/actions/controlflow/internal/Cfg.qll +++ b/actions/ql/lib/codeql/actions/controlflow/internal/Cfg.qll @@ -101,14 +101,8 @@ private module Implementation implements CfgShared::InputSig { last(scope.(CompositeAction), e, c) } - predicate successorTypeIsSimple(SuccessorType t) { t instanceof DirectSuccessor } - - predicate successorTypeIsCondition(SuccessorType t) { t instanceof BooleanSuccessor } - SuccessorType getAMatchingSuccessorType(Completion c) { result = c.getAMatchingSuccessorType() } - predicate isAbnormalExitType(SuccessorType t) { none() } - int idOfAstNode(AstNode node) { none() } int idOfCfgScope(CfgScope scope) { none() } diff --git a/cpp/ql/lib/semmle/code/cpp/ir/implementation/EdgeKind.qll b/cpp/ql/lib/semmle/code/cpp/ir/implementation/EdgeKind.qll index 0a0703fe16f..c7ab5edf624 100644 --- a/cpp/ql/lib/semmle/code/cpp/ir/implementation/EdgeKind.qll +++ b/cpp/ql/lib/semmle/code/cpp/ir/implementation/EdgeKind.qll @@ -2,6 +2,7 @@ * Provides classes that specify the conditions under which control flows along a given edge. */ +private import codeql.controlflow.SuccessorType private import internal.EdgeKindInternal private newtype TEdgeKind = @@ -28,6 +29,21 @@ abstract private class EdgeKindImpl extends TEdgeKind { final class EdgeKind = EdgeKindImpl; +private SuccessorType getAMatchingSpecificSuccessorType(EdgeKind k) { + result.(BooleanSuccessor).getValue() = true and k instanceof TrueEdge + or + result.(BooleanSuccessor).getValue() = false and k instanceof FalseEdge + or + result instanceof ExceptionSuccessor and k instanceof ExceptionEdge +} + +SuccessorType getAMatchingSuccessorType(EdgeKind k) { + result = getAMatchingSpecificSuccessorType(k) + or + not exists(getAMatchingSpecificSuccessorType(k)) and + result instanceof DirectSuccessor +} + /** * A "goto" edge, representing the unconditional successor of an `Instruction` * or `IRBlock`. diff --git a/cpp/ql/lib/semmle/code/cpp/ir/implementation/aliased_ssa/IRBlock.qll b/cpp/ql/lib/semmle/code/cpp/ir/implementation/aliased_ssa/IRBlock.qll index 89efaa8e15a..7f7c5cd0a4d 100644 --- a/cpp/ql/lib/semmle/code/cpp/ir/implementation/aliased_ssa/IRBlock.qll +++ b/cpp/ql/lib/semmle/code/cpp/ir/implementation/aliased_ssa/IRBlock.qll @@ -265,9 +265,9 @@ private predicate isEntryBlock(TIRBlock block) { } module IRCfg implements BB::CfgSig { - class ControlFlowNode = Instruction; + private import codeql.controlflow.SuccessorType - class SuccessorType = EdgeKind; + class ControlFlowNode = Instruction; final private class FinalIRBlock = IRBlock; @@ -280,7 +280,12 @@ module IRCfg implements BB::CfgSig { BasicBlock getASuccessor() { result = super.getASuccessor() } - BasicBlock getASuccessor(SuccessorType t) { result = super.getSuccessor(t) } + BasicBlock getASuccessor(SuccessorType t) { + exists(EdgeKind k | + result = super.getSuccessor(k) and + t = getAMatchingSuccessorType(k) + ) + } predicate strictlyDominates(BasicBlock bb) { super.strictlyDominates(bb) } diff --git a/cpp/ql/lib/semmle/code/cpp/ir/implementation/raw/IRBlock.qll b/cpp/ql/lib/semmle/code/cpp/ir/implementation/raw/IRBlock.qll index 89efaa8e15a..7f7c5cd0a4d 100644 --- a/cpp/ql/lib/semmle/code/cpp/ir/implementation/raw/IRBlock.qll +++ b/cpp/ql/lib/semmle/code/cpp/ir/implementation/raw/IRBlock.qll @@ -265,9 +265,9 @@ private predicate isEntryBlock(TIRBlock block) { } module IRCfg implements BB::CfgSig { - class ControlFlowNode = Instruction; + private import codeql.controlflow.SuccessorType - class SuccessorType = EdgeKind; + class ControlFlowNode = Instruction; final private class FinalIRBlock = IRBlock; @@ -280,7 +280,12 @@ module IRCfg implements BB::CfgSig { BasicBlock getASuccessor() { result = super.getASuccessor() } - BasicBlock getASuccessor(SuccessorType t) { result = super.getSuccessor(t) } + BasicBlock getASuccessor(SuccessorType t) { + exists(EdgeKind k | + result = super.getSuccessor(k) and + t = getAMatchingSuccessorType(k) + ) + } predicate strictlyDominates(BasicBlock bb) { super.strictlyDominates(bb) } diff --git a/cpp/ql/lib/semmle/code/cpp/ir/implementation/unaliased_ssa/IRBlock.qll b/cpp/ql/lib/semmle/code/cpp/ir/implementation/unaliased_ssa/IRBlock.qll index 89efaa8e15a..7f7c5cd0a4d 100644 --- a/cpp/ql/lib/semmle/code/cpp/ir/implementation/unaliased_ssa/IRBlock.qll +++ b/cpp/ql/lib/semmle/code/cpp/ir/implementation/unaliased_ssa/IRBlock.qll @@ -265,9 +265,9 @@ private predicate isEntryBlock(TIRBlock block) { } module IRCfg implements BB::CfgSig { - class ControlFlowNode = Instruction; + private import codeql.controlflow.SuccessorType - class SuccessorType = EdgeKind; + class ControlFlowNode = Instruction; final private class FinalIRBlock = IRBlock; @@ -280,7 +280,12 @@ module IRCfg implements BB::CfgSig { BasicBlock getASuccessor() { result = super.getASuccessor() } - BasicBlock getASuccessor(SuccessorType t) { result = super.getSuccessor(t) } + BasicBlock getASuccessor(SuccessorType t) { + exists(EdgeKind k | + result = super.getSuccessor(k) and + t = getAMatchingSuccessorType(k) + ) + } predicate strictlyDominates(BasicBlock bb) { super.strictlyDominates(bb) } diff --git a/csharp/ql/lib/semmle/code/csharp/controlflow/BasicBlocks.qll b/csharp/ql/lib/semmle/code/csharp/controlflow/BasicBlocks.qll index cc628d9792b..bf6a9772857 100644 --- a/csharp/ql/lib/semmle/code/csharp/controlflow/BasicBlocks.qll +++ b/csharp/ql/lib/semmle/code/csharp/controlflow/BasicBlocks.qll @@ -346,8 +346,6 @@ private class EntryBasicBlockAlias = EntryBasicBlock; module Cfg implements BB::CfgSig { class ControlFlowNode = ControlFlow::Node; - class SuccessorType = ControlFlow::SuccessorType; - class BasicBlock = BasicBlockAlias; class EntryBasicBlock = EntryBasicBlockAlias; diff --git a/csharp/ql/lib/semmle/code/csharp/controlflow/internal/ControlFlowGraphImpl.qll b/csharp/ql/lib/semmle/code/csharp/controlflow/internal/ControlFlowGraphImpl.qll index cde366f0014..5f62d6d21df 100644 --- a/csharp/ql/lib/semmle/code/csharp/controlflow/internal/ControlFlowGraphImpl.qll +++ b/csharp/ql/lib/semmle/code/csharp/controlflow/internal/ControlFlowGraphImpl.qll @@ -79,19 +79,10 @@ private module CfgInput implements CfgShared::InputSig { Impl::scopeLast(scope, last, c) } - class SuccessorType = ST::SuccessorType; + private class SuccessorType = ST::SuccessorType; SuccessorType getAMatchingSuccessorType(Completion c) { result = c.getAMatchingSuccessorType() } - predicate successorTypeIsSimple(SuccessorType t) { t instanceof ST::DirectSuccessor } - - predicate successorTypeIsCondition(SuccessorType t) { t instanceof ST::ConditionalSuccessor } - - predicate isAbnormalExitType(SuccessorType t) { - t instanceof ST::ExceptionSuccessor or - t instanceof ST::ExitSuccessor - } - int idOfAstNode(AstNode node) { result = node.getId() } int idOfCfgScope(CfgScope node) { result = idOfAstNode(node) } diff --git a/csharp/ql/lib/semmle/code/csharp/controlflow/internal/PreBasicBlocks.qll b/csharp/ql/lib/semmle/code/csharp/controlflow/internal/PreBasicBlocks.qll index 3997207ed99..38eca378edf 100644 --- a/csharp/ql/lib/semmle/code/csharp/controlflow/internal/PreBasicBlocks.qll +++ b/csharp/ql/lib/semmle/code/csharp/controlflow/internal/PreBasicBlocks.qll @@ -163,8 +163,6 @@ class ConditionBlock extends PreBasicBlock { module PreCfg implements BB::CfgSig { class ControlFlowNode = ControlFlowElement; - class SuccessorType = Cfg::SuccessorType; - class BasicBlock = PreBasicBlock; class EntryBasicBlock extends BasicBlock { diff --git a/java/ql/lib/semmle/code/java/controlflow/BasicBlocks.qll b/java/ql/lib/semmle/code/java/controlflow/BasicBlocks.qll index 1ead72a2087..b08c59d4630 100644 --- a/java/ql/lib/semmle/code/java/controlflow/BasicBlocks.qll +++ b/java/ql/lib/semmle/code/java/controlflow/BasicBlocks.qll @@ -7,10 +7,9 @@ module; import java import Dominance private import codeql.controlflow.BasicBlock as BB +private import codeql.controlflow.SuccessorType private module Input implements BB::InputSig { - import codeql.controlflow.SuccessorType - /** Hold if `t` represents a conditional successor type. */ predicate successorTypeIsCondition(SuccessorType t) { none() } @@ -96,7 +95,7 @@ class BasicBlock extends BbImpl::BasicBlock { predicate strictlyDominates(BasicBlock bb) { super.strictlyDominates(bb) } /** Gets an immediate successor of this basic block of a given type, if any. */ - BasicBlock getASuccessor(Input::SuccessorType t) { result = super.getASuccessor(t) } + BasicBlock getASuccessor(SuccessorType t) { result = super.getASuccessor(t) } BasicBlock getASuccessor() { result = super.getASuccessor() } @@ -161,8 +160,6 @@ private class BasicBlockAlias = BasicBlock; module Cfg implements BB::CfgSig { class ControlFlowNode = BbImpl::ControlFlowNode; - class SuccessorType = BbImpl::SuccessorType; - class BasicBlock = BasicBlockAlias; class EntryBasicBlock extends BasicBlock instanceof BbImpl::EntryBasicBlock { } diff --git a/java/ql/lib/semmle/code/java/controlflow/Guards.qll b/java/ql/lib/semmle/code/java/controlflow/Guards.qll index d009b625d9c..45983a10a27 100644 --- a/java/ql/lib/semmle/code/java/controlflow/Guards.qll +++ b/java/ql/lib/semmle/code/java/controlflow/Guards.qll @@ -139,7 +139,7 @@ private predicate isNonFallThroughPredecessor(SwitchCase sc, ControlFlowNode pre ) } -private module SuccessorTypes implements SharedGuards::SuccessorTypesSig { +private module SuccessorTypes implements SharedGuards::SuccessorTypesSig { import codeql.controlflow.SuccessorType } diff --git a/javascript/ql/lib/semmle/javascript/internal/BasicBlockInternal.qll b/javascript/ql/lib/semmle/javascript/internal/BasicBlockInternal.qll index 6742429b15e..d8e4a18dfc1 100644 --- a/javascript/ql/lib/semmle/javascript/internal/BasicBlockInternal.qll +++ b/javascript/ql/lib/semmle/javascript/internal/BasicBlockInternal.qll @@ -372,16 +372,28 @@ module Public { module Cfg implements BB::CfgSig { private import javascript as Js - private import codeql.util.Unit + private import codeql.controlflow.SuccessorType class ControlFlowNode = Js::ControlFlowNode; - class SuccessorType = Unit; + private predicate conditionSucc(BasicBlock bb1, BasicBlock bb2, boolean branch) { + exists(ConditionGuardNode g | + bb1 = g.getTest().getBasicBlock() and + bb2 = g.getBasicBlock() and + branch = g.getOutcome() + ) + } class BasicBlock extends FinalBasicBlock { BasicBlock getASuccessor() { result = super.getASuccessor() } - BasicBlock getASuccessor(SuccessorType t) { result = super.getASuccessor() and exists(t) } + BasicBlock getASuccessor(SuccessorType t) { + conditionSucc(this, result, t.(BooleanSuccessor).getValue()) + or + result = super.getASuccessor() and + t instanceof DirectSuccessor and + not conditionSucc(this, result, _) + } predicate strictlyDominates(BasicBlock bb) { this.(ReachableBasicBlock).strictlyDominates(bb) diff --git a/python/ql/lib/semmle/python/Flow.qll b/python/ql/lib/semmle/python/Flow.qll index c91a492e269..621013adcd5 100644 --- a/python/ql/lib/semmle/python/Flow.qll +++ b/python/ql/lib/semmle/python/Flow.qll @@ -1259,9 +1259,9 @@ private class ControlFlowNodeAlias = ControlFlowNode; final private class FinalBasicBlock = BasicBlock; module Cfg implements BB::CfgSig { - class ControlFlowNode = ControlFlowNodeAlias; + private import codeql.controlflow.SuccessorType - class SuccessorType = Unit; + class ControlFlowNode = ControlFlowNodeAlias; class BasicBlock extends FinalBasicBlock { // Note `PY:BasicBlock` does not have a `getLocation`. @@ -1275,7 +1275,24 @@ module Cfg implements BB::CfgSig { BasicBlock getASuccessor() { result = super.getASuccessor() } - BasicBlock getASuccessor(SuccessorType t) { result = super.getASuccessor() and exists(t) } + private BasicBlock getANonDirectSuccessor(SuccessorType t) { + result = this.getATrueSuccessor() and + t.(BooleanSuccessor).getValue() = true + or + result = this.getAFalseSuccessor() and + t.(BooleanSuccessor).getValue() = false + or + result = this.getAnExceptionalSuccessor() and + t instanceof ExceptionSuccessor + } + + BasicBlock getASuccessor(SuccessorType t) { + result = this.getANonDirectSuccessor(t) + or + result = super.getASuccessor() and + t instanceof DirectSuccessor and + not result = this.getANonDirectSuccessor(_) + } predicate strictlyDominates(BasicBlock bb) { super.strictlyDominates(bb) } diff --git a/ruby/ql/lib/codeql/ruby/controlflow/BasicBlocks.qll b/ruby/ql/lib/codeql/ruby/controlflow/BasicBlocks.qll index 72d8360b24c..e085dbd90a3 100644 --- a/ruby/ql/lib/codeql/ruby/controlflow/BasicBlocks.qll +++ b/ruby/ql/lib/codeql/ruby/controlflow/BasicBlocks.qll @@ -301,13 +301,9 @@ private class BasicBlockAlias = BasicBlock; private class EntryBasicBlockAlias = EntryBasicBlock; -private class SuccessorTypeAlias = SuccessorType; - module Cfg implements BB::CfgSig { class ControlFlowNode = CfgNode; - class SuccessorType = SuccessorTypeAlias; - class BasicBlock = BasicBlockAlias; class EntryBasicBlock = EntryBasicBlockAlias; diff --git a/ruby/ql/lib/codeql/ruby/controlflow/internal/ControlFlowGraphImpl.qll b/ruby/ql/lib/codeql/ruby/controlflow/internal/ControlFlowGraphImpl.qll index d45f6f19cdf..f564633bb00 100644 --- a/ruby/ql/lib/codeql/ruby/controlflow/internal/ControlFlowGraphImpl.qll +++ b/ruby/ql/lib/codeql/ruby/controlflow/internal/ControlFlowGraphImpl.qll @@ -46,19 +46,10 @@ private module CfgInput implements CfgShared::InputSig { scope.(Impl::CfgScopeImpl).exit(last, c) } - class SuccessorType = Cfg::SuccessorType; + private class SuccessorType = Cfg::SuccessorType; SuccessorType getAMatchingSuccessorType(Completion c) { result = c.getAMatchingSuccessorType() } - predicate successorTypeIsSimple(SuccessorType t) { t instanceof Cfg::DirectSuccessor } - - predicate successorTypeIsCondition(SuccessorType t) { t instanceof Cfg::ConditionalSuccessor } - - predicate isAbnormalExitType(SuccessorType t) { - t instanceof Cfg::ExceptionSuccessor or - t instanceof Cfg::ExitSuccessor - } - private predicate id(Ruby::AstNode node1, Ruby::AstNode node2) { node1 = node2 } private predicate idOf(Ruby::AstNode node, int id) = equivalenceRelation(id/2)(node, id) diff --git a/rust/ql/lib/codeql/rust/controlflow/BasicBlocks.qll b/rust/ql/lib/codeql/rust/controlflow/BasicBlocks.qll index daa2cb1e818..4ed93544023 100644 --- a/rust/ql/lib/codeql/rust/controlflow/BasicBlocks.qll +++ b/rust/ql/lib/codeql/rust/controlflow/BasicBlocks.qll @@ -21,8 +21,6 @@ final class JoinPredecessorBasicBlock = BasicBlocksImpl::JoinPredecessorBasicBlo module Cfg implements BB::CfgSig { class ControlFlowNode = ControlFlowGraph::CfgNode; - class SuccessorType = ControlFlowGraph::SuccessorType; - class BasicBlock = BasicBlocksImpl::BasicBlock; class EntryBasicBlock = BasicBlocksImpl::EntryBasicBlock; diff --git a/rust/ql/lib/codeql/rust/controlflow/internal/ControlFlowGraphImpl.qll b/rust/ql/lib/codeql/rust/controlflow/internal/ControlFlowGraphImpl.qll index b7607aa025b..ddc4dae9b95 100644 --- a/rust/ql/lib/codeql/rust/controlflow/internal/ControlFlowGraphImpl.qll +++ b/rust/ql/lib/codeql/rust/controlflow/internal/ControlFlowGraphImpl.qll @@ -29,19 +29,11 @@ private module CfgInput implements InputSig { Stages::CfgStage::ref() } - class SuccessorType = Cfg::SuccessorType; + private class SuccessorType = Cfg::SuccessorType; /** Gets a successor type that matches completion `c`. */ SuccessorType getAMatchingSuccessorType(Completion c) { result = c.getAMatchingSuccessorType() } - /** - * Hold if `c` represents simple (normal) evaluation of a statement or an expression. - */ - predicate successorTypeIsSimple(SuccessorType t) { t instanceof Cfg::DirectSuccessor } - - /** Holds if `t` is an abnormal exit type out of a CFG scope. */ - predicate isAbnormalExitType(SuccessorType t) { none() } - /** Hold if `t` represents a conditional successor type. */ predicate successorTypeIsCondition(SuccessorType t) { t instanceof Cfg::BooleanSuccessor } diff --git a/shared/controlflow/codeql/controlflow/BasicBlock.qll b/shared/controlflow/codeql/controlflow/BasicBlock.qll index 7aa541b4630..ed86ae5aa8b 100644 --- a/shared/controlflow/codeql/controlflow/BasicBlock.qll +++ b/shared/controlflow/codeql/controlflow/BasicBlock.qll @@ -9,17 +9,12 @@ overlay[local?] module; private import codeql.util.Location +private import SuccessorType /** Provides the language-specific input specification. */ signature module InputSig { - /** The type of a control flow successor. */ - class SuccessorType { - /** Gets a textual representation of this successor type. */ - string toString(); - } - /** Hold if `t` represents a conditional successor type. */ - predicate successorTypeIsCondition(SuccessorType t); + default predicate successorTypeIsCondition(SuccessorType t) { t instanceof ConditionalSuccessor } /** A delineated part of the AST with its own CFG. */ class CfgScope; @@ -61,12 +56,6 @@ signature module CfgSig { Location getLocation(); } - /** The type of a control flow successor. */ - class SuccessorType { - /** Gets a textual representation of this successor type. */ - string toString(); - } - /** * A basic block, that is, a maximal straight-line sequence of control flow nodes * without branches or joins. @@ -180,8 +169,6 @@ module Make Input> implements CfgSig { @@ -59,26 +60,11 @@ signature module InputSig { /** Holds if `scope` is exited when `last` finishes with completion `c`. */ predicate scopeLast(CfgScope scope, AstNode last, Completion c); - /** A type of a control flow successor. */ - class SuccessorType { - /** Gets a textual representation of this successor type. */ - string toString(); - } - /** Gets a successor type that matches completion `c`. */ SuccessorType getAMatchingSuccessorType(Completion c); - /** - * Hold if `t` represents simple (normal) evaluation of a statement or an - * expression. - */ - predicate successorTypeIsSimple(SuccessorType t); - /** Hold if `t` represents a conditional successor type. */ - predicate successorTypeIsCondition(SuccessorType t); - - /** Holds if `t` is an abnormal exit type out of a CFG scope. */ - predicate isAbnormalExitType(SuccessorType t); + default predicate successorTypeIsCondition(SuccessorType t) { t instanceof ConditionalSuccessor } /** * Gets an `id` of `node`. This is used to order the predecessors of a join @@ -522,7 +508,7 @@ module MakeWithSplitting< private predicate succEntrySplits(CfgScope pred, AstNode succ, Splits succSplits, SuccessorType t) { exists(int rnk | scopeFirst(pred, succ) and - successorTypeIsSimple(t) and + t instanceof DirectSuccessor and succEntrySplitsFromRank(pred, succ, succSplits, rnk) | rnk = 0 and @@ -1016,7 +1002,7 @@ module MakeWithSplitting< exists(CfgScope scope | pred = TAnnotatedExitNode(scope, _) and result = TExitNode(scope) and - successorTypeIsSimple(t) + t instanceof DirectSuccessor ) } @@ -1320,7 +1306,7 @@ module MakeWithSplitting< label = strictconcat(SuccessorType t, string s | succ = getASuccessor(pred, t) and - if successorTypeIsSimple(t) then s = "" else s = t.toString() + if t instanceof DirectSuccessor then s = "" else s = t.toString() | s, ", " order by s ) @@ -1590,8 +1576,6 @@ module MakeWithSplitting< private class NodeAlias = Node; private module BasicBlockInputSig implements BB::InputSig { - class SuccessorType = Input::SuccessorType; - predicate successorTypeIsCondition = Input::successorTypeIsCondition/1; class CfgScope = CfgScopeAlias; diff --git a/shared/controlflow/codeql/controlflow/Guards.qll b/shared/controlflow/codeql/controlflow/Guards.qll index f39cb67b7e1..fb32157654b 100644 --- a/shared/controlflow/codeql/controlflow/Guards.qll +++ b/shared/controlflow/codeql/controlflow/Guards.qll @@ -51,16 +51,17 @@ overlay[local?] module; private import codeql.controlflow.BasicBlock as BB +private import codeql.controlflow.SuccessorType as ST private import codeql.util.Boolean private import codeql.util.Location private import codeql.util.Unit signature class TypSig; -signature module SuccessorTypesSig { - class ExceptionSuccessor extends SuccessorType; +signature module SuccessorTypesSig { + class ExceptionSuccessor extends ST::SuccessorType; - class ConditionalSuccessor extends SuccessorType { + class ConditionalSuccessor extends ST::SuccessorType { /** Gets the Boolean value of this successor. */ boolean getValue(); } @@ -204,8 +205,7 @@ signature module InputSig Cfg, - SuccessorTypesSig SuccessorTypes, + LocationSig Location, BB::CfgSig Cfg, SuccessorTypesSig SuccessorTypes, InputSig Input> { private module Cfg_ = Cfg; @@ -320,7 +320,7 @@ module Make< } private predicate exceptionBranchPoint(BasicBlock bb1, BasicBlock normalSucc, BasicBlock excSucc) { - exists(SuccessorType norm, ExceptionSuccessor exc | + exists(ST::SuccessorType norm, ExceptionSuccessor exc | bb1.getASuccessor(norm) = normalSucc and bb1.getASuccessor(exc) = excSucc and normalSucc != excSucc and diff --git a/shared/controlflow/codeql/controlflow/SuccessorType.qll b/shared/controlflow/codeql/controlflow/SuccessorType.qll index 029d52f5cb7..9dcbbc9bd27 100644 --- a/shared/controlflow/codeql/controlflow/SuccessorType.qll +++ b/shared/controlflow/codeql/controlflow/SuccessorType.qll @@ -339,3 +339,9 @@ class RetrySuccessor extends JumpSuccessor, TRetrySuccessor { class JavaYieldSuccessor extends JumpSuccessor, TJavaYieldSuccessor { override string toString() { result = "yield" } } + +/** Holds if `t` is an abnormal exit type out of a CFG scope. */ +predicate isAbnormalExitType(SuccessorType t) { + t instanceof ExceptionSuccessor or + t instanceof ExitSuccessor +} diff --git a/swift/ql/lib/codeql/swift/controlflow/BasicBlocks.qll b/swift/ql/lib/codeql/swift/controlflow/BasicBlocks.qll index 3ff42e01d18..e5acea49fda 100644 --- a/swift/ql/lib/codeql/swift/controlflow/BasicBlocks.qll +++ b/swift/ql/lib/codeql/swift/controlflow/BasicBlocks.qll @@ -119,13 +119,9 @@ private class EntryBasicBlockAlias = EntryBasicBlock; private class ControlFlowNodeAlias = ControlFlowNode; -private class SuccessorTypeAlias = SuccessorType; - module Cfg implements BB::CfgSig { class ControlFlowNode = ControlFlowNodeAlias; - class SuccessorType = SuccessorTypeAlias; - class BasicBlock = BasicBlockAlias; class EntryBasicBlock = EntryBasicBlockAlias; diff --git a/swift/ql/lib/codeql/swift/controlflow/internal/ControlFlowGraphImplSpecific.qll b/swift/ql/lib/codeql/swift/controlflow/internal/ControlFlowGraphImplSpecific.qll index 1902e045467..37625e0be10 100644 --- a/swift/ql/lib/codeql/swift/controlflow/internal/ControlFlowGraphImplSpecific.qll +++ b/swift/ql/lib/codeql/swift/controlflow/internal/ControlFlowGraphImplSpecific.qll @@ -48,29 +48,11 @@ module CfgInput implements InputSig { CfgScope getCfgScope(AstNode n) { result = scopeOfAst(n.asAstNode()) } - class SuccessorType = Cfg::SuccessorType; + private class SuccessorType = Cfg::SuccessorType; /** Gets a successor type that matches completion `c`. */ SuccessorType getAMatchingSuccessorType(Completion c) { result = c.getAMatchingSuccessorType() } - /** - * Hold if `c` represents simple (normal) evaluation of a statement or an - * expression. - */ - predicate successorTypeIsSimple(SuccessorType t) { t instanceof Cfg::DirectSuccessor } - - /** Holds if `t` is an abnormal exit type out of a CFG scope. */ - predicate isAbnormalExitType(SuccessorType t) { t instanceof Cfg::ExceptionSuccessor } - - /** Hold if `t` represents a conditional successor type. */ - predicate successorTypeIsCondition(SuccessorType t) { - t instanceof Cfg::BooleanSuccessor or - t instanceof Cfg::BreakSuccessor or - t instanceof Cfg::ContinueSuccessor or - t instanceof Cfg::MatchingSuccessor or - t instanceof Cfg::EmptinessSuccessor - } - /** Holds if `first` is first executed when entering `scope`. */ predicate scopeFirst(CfgScope scope, AstNode first) { scope.(Impl::CfgScope::Range_).entry(first)