C#: Refactor to align implementation between languages.

Author: michaelnebel

csharp/ql/lib/semmle/code/csharp/dataflow/ExternalFlow.qll

@@ -515,7 +515,9 @@ Element interpretElement(
 /**
  * Holds if `c` has a `generated` summary.
  */
-predicate hasSummary(Callable c, boolean generated) { summaryElement(c, _, _, _, generated) }
+predicate hasSummary(Callable c, boolean generated) {
+  exists(DataFlowCallable dc | dc.asCallable() = c and summaryElement(dc, _, _, _, generated))
+}
 
 cached
 private module Cached {

csharp/ql/lib/semmle/code/csharp/dataflow/internal/DataFlowDispatch.qll

@@ -144,8 +144,8 @@ private module DispatchImpl {
    * call is a delegate call, or if the qualifier accesses a parameter of
    * the enclosing callable `c` (including the implicit `this` parameter).
    */
-  predicate mayBenefitFromCallContext(NonDelegateDataFlowCall call, Callable c) {
-    c = call.getEnclosingCallable().asCallable() and
+  predicate mayBenefitFromCallContext(NonDelegateDataFlowCall call, DataFlowCallable c) {
+    c = call.getEnclosingCallable() and
     call.getDispatchCall().mayBenefitFromCallContext()
   }
 

csharp/ql/lib/semmle/code/csharp/dataflow/internal/DataFlowImplCommon.qll

@@ -698,7 +698,7 @@ private module Cached {
      */
     pragma[nomagic]
     private predicate mayBenefitFromCallContextExt(DataFlowCall call, DataFlowCallable callable) {
-      mayBenefitFromCallContext(call, callable.asCallable())
+      mayBenefitFromCallContext(call, callable)
       or
       callEnclosingCallable(call, callable) and
       exists(viableCallableLambda(call, TDataFlowCallSome(_)))

csharp/ql/lib/semmle/code/csharp/dataflow/internal/DataFlowPrivate.qll

@@ -19,7 +19,7 @@ private import semmle.code.csharp.frameworks.system.Collections
 private import semmle.code.csharp.frameworks.system.threading.Tasks
 
 /** Gets the callable in which this node occurs. */
-DataFlowCallable nodeGetEnclosingCallable(Node n) { result = n.getEnclosingCallable() }
+DataFlowCallable nodeGetEnclosingCallable(Node n) { result.asCallable() = n.getEnclosingCallable() }
 
 /** Holds if `p` is a `ParameterNode` of `c` with position `pos`. */
 predicate isParameterNode(ParameterNodeImpl p, DataFlowCallable c, ParameterPosition pos) {
@@ -960,7 +960,7 @@ private module ParameterNodes {
 
     override predicate isParameterOf(DataFlowCallable c, ParameterPosition pos) {
       pos.isImplicitCapturedParameterPosition(def.getSourceVariable().getAssignable()) and
-      c = this.getEnclosingCallable()
+      c.asCallable() = this.getEnclosingCallable()
     }
   }
 }
@@ -1384,7 +1384,7 @@ private module OutNodes {
         additionalCalls = false and call = csharpCall(_, cfn)
         or
         additionalCalls = true and
-        call = TTransitiveCapturedCall(cfn, n.getEnclosingCallable().asCallable())
+        call = TTransitiveCapturedCall(cfn, n.getEnclosingCallable())
       )
     }
 

csharp/ql/lib/semmle/code/csharp/dataflow/internal/DataFlowPublic.qll

@@ -40,8 +40,8 @@ class Node extends TNode {
   final DotNet::Type getType() { result = this.(NodeImpl).getTypeImpl() }
 
   /** Gets the enclosing callable of this node. */
-  final DataFlowCallable getEnclosingCallable() {
-    result = this.(NodeImpl).getEnclosingCallableImpl()
+  final Callable getEnclosingCallable() {
+    result = this.(NodeImpl).getEnclosingCallableImpl().asCallable()
   }
 
   /** Gets the control flow node corresponding to this node, if any. */

csharp/ql/lib/semmle/code/csharp/dataflow/internal/DelegateDataFlow.qll

@@ -269,7 +269,7 @@ deprecated private predicate flowIntoDelegateCall(DelegateLikeCall call, Callabl
 
 pragma[noinline]
 private predicate flowOutOfNonDelegateCall(NonDelegateCall call, NormalReturnNode ret) {
-  call.getARuntimeTarget() = ret.getEnclosingCallable().asCallable()
+  call.getARuntimeTarget() = ret.getEnclosingCallable()
 }
 
 pragma[noinline]
@@ -278,7 +278,7 @@ deprecated private predicate flowOutOfDelegateCall(
 ) {
   exists(DelegateLikeFlowSource dfs, DelegateLikeCallExpr dce, Callable c |
     flowsFrom(dce, dfs, _, lastCall) and
-    ret.getEnclosingCallable().asCallable() = c and
+    ret.getEnclosingCallable() = c and
     c = dfs.getCallable() and
     dc = dce.getCall()
   )

csharp/ql/lib/semmle/code/csharp/dataflow/internal/FlowSummaryImpl.qll

@@ -910,13 +910,13 @@ module Private {
     }
 
     private class SummarizedCallableExternal extends SummarizedCallable {
-      SummarizedCallableExternal() { summaryElement(this.asCallable(), _, _, _, _) }
+      SummarizedCallableExternal() { summaryElement(this, _, _, _, _) }
 
       private predicate relevantSummaryElement(AccessPath inSpec, AccessPath outSpec, string kind) {
-        summaryElement(this.asCallable(), inSpec, outSpec, kind, false)
+        summaryElement(this, inSpec, outSpec, kind, false)
         or
-        summaryElement(this.asCallable(), inSpec, outSpec, kind, true) and
-        not summaryElement(this.asCallable(), _, _, _, false)
+        summaryElement(this, inSpec, outSpec, kind, true) and
+        not summaryElement(this, _, _, _, false)
       }
 
       override predicate propagatesFlow(
@@ -933,7 +933,7 @@ module Private {
         )
       }
 
-      override predicate isAutoGenerated() { summaryElement(this.asCallable(), _, _, _, true) }
+      override predicate isAutoGenerated() { summaryElement(this, _, _, _, true) }
     }
 
     /** Holds if component `c` of specification `spec` cannot be parsed. */

csharp/ql/lib/semmle/code/csharp/dataflow/internal/FlowSummaryImplSpecific.qll

@@ -90,13 +90,13 @@ DataFlowType getCallbackReturnType(DataFlowType t, ReturnKind rk) {
  * stating whether the summary is autogenerated.
  */
 predicate summaryElement(
-  DotNet::Callable c, string input, string output, string kind, boolean generated
+  DataFlowCallable c, string input, string output, string kind, boolean generated
 ) {
   exists(
     string namespace, string type, boolean subtypes, string name, string signature, string ext
   |
     summaryModel(namespace, type, subtypes, name, signature, ext, input, output, kind, generated) and
-    c = interpretElement(namespace, type, subtypes, name, signature, ext)
+    c.asCallable() = interpretElement(namespace, type, subtypes, name, signature, ext)
   )
 }
 

csharp/ql/src/API Abuse/NoDisposeCallOnLocalIDisposable.ql

@@ -99,7 +99,7 @@ predicate mayNotBeDisposed(LocalScopeDisposableCreation disposable) {
     not exists(DataFlow::Node sink | conf.hasFlow(DataFlow::exprNode(disposable), sink) |
       sink instanceof ReturnNode
       implies
-      sink.getEnclosingCallable().asCallable() = disposable.getEnclosingCallable()
+      sink.getEnclosingCallable() = disposable.getEnclosingCallable()
     )
   )
 }

csharp/ql/src/utils/model-generator/internal/CaptureModels.qll

@@ -131,7 +131,7 @@ private class ThroughFlowConfig extends TaintTracking::Configuration {
 
   override predicate isSource(DataFlow::Node source, DataFlow::FlowState state) {
     source instanceof DataFlow::ParameterNode and
-    source.getEnclosingCallable().asCallable() instanceof TargetApi and
+    source.getEnclosingCallable() instanceof TargetApi and
     state.(TaintRead).getStep() = 0
   }
 
@@ -181,7 +181,7 @@ string captureThroughFlow(TargetApi api) {
     DataFlowImplCommon::ReturnNodeExt returnNodeExt, string input, string output
   |
     config.hasFlow(p, returnNodeExt) and
-    returnNodeExt.getEnclosingCallable().asCallable() = api and
+    returnNodeExt.getEnclosingCallable() = api and
     input = parameterNodeAsInput(p) and
     output = returnNodeAsOutput(returnNodeExt) and
     input != output and
@@ -204,7 +204,7 @@ private class FromSourceConfiguration extends TaintTracking::Configuration {
   override predicate isSink(DataFlow::Node sink) {
     exists(TargetApi c |
       sink instanceof DataFlowImplCommon::ReturnNodeExt and
-      sink.getEnclosingCallable().asCallable() = c
+      sink.getEnclosingCallable() = c
     )
   }
 
@@ -224,7 +224,7 @@ string captureSource(TargetApi api) {
   exists(DataFlow::Node source, DataFlow::Node sink, FromSourceConfiguration config, string kind |
     config.hasFlow(source, sink) and
     ExternalFlow::sourceNode(source, kind) and
-    api = sink.getEnclosingCallable().asCallable() and
+    api = sink.getEnclosingCallable() and
     result = asSourceModel(api, returnNodeAsOutput(sink), kind)
   )
 }
@@ -253,7 +253,7 @@ string captureSink(TargetApi api) {
   exists(DataFlow::Node src, DataFlow::Node sink, PropagateToSinkConfiguration config, string kind |
     config.hasFlow(src, sink) and
     ExternalFlow::sinkNode(sink, kind) and
-    api = src.getEnclosingCallable().asCallable() and
+    api = src.getEnclosingCallable() and
     isRelevantSinkKind(kind) and
     result = asSinkModel(api, asInputArgument(src), kind)
   )