construction

Author: hvitved

rust/ql/lib/codeql/rust/internal/typeinference/TypeInference.qll

@@ -582,6 +582,137 @@ private module Input3 implements InputSig3 {
     }
   }
 
+  final class Constructor = ConstructorImpl;
+
+  abstract private class ConstructorImpl extends Addressable {
+    TypeMention getAdditionalTypeParameterConstraint(TypeParameter tp) { none() }
+
+    final TypeParameter getTypeParameter(TypeParameterPosition ppos) {
+      result = ppos.asTypeParameter() and
+      ppos.asTypeParam() = this.getTypeItem().getGenericParamList().getATypeParam()
+    }
+
+    abstract TypeItem getTypeItem();
+
+    abstract TypeRepr getParameterTypeRepr(int pos);
+
+    Type getParameterType(int pos, TypePath path) {
+      result = this.getParameterTypeRepr(pos).(TypeMention).getTypeAt(path)
+    }
+
+    Type getReturnType(TypePath path) {
+      result = TDataType(this.getTypeItem()) and
+      path.isEmpty()
+      or
+      result = TTypeParamTypeParameter(this.getTypeItem().getGenericParamList().getATypeParam()) and
+      path = TypePath::singleton(result)
+    }
+  }
+
+  private class StructConstructor extends ConstructorImpl instanceof Struct {
+    override TypeItem getTypeItem() { result = this }
+
+    override TypeRepr getParameterTypeRepr(int i) {
+      result = [super.getTupleField(i).getTypeRepr(), super.getNthStructField(i).getTypeRepr()]
+    }
+  }
+
+  private class VariantConstructor extends ConstructorImpl instanceof Variant {
+    override TypeItem getTypeItem() { result = super.getEnum() }
+
+    override TypeRepr getParameterTypeRepr(int i) {
+      result = [super.getTupleField(i).getTypeRepr(), super.getNthStructField(i).getTypeRepr()]
+    }
+  }
+
+  abstract class Construction extends Expr {
+    abstract Constructor getTarget();
+
+    abstract AstNode getArgument(int i);
+
+    abstract Type getTypeArgument(TypeArgumentPosition apos, TypePath path);
+
+    /**
+     * Holds if the return type of this construction expression at `path` may
+     * have to be inferred from the context. For example in `Result::Ok(42)` the
+     * error type has to be inferred from the context.
+     */
+    pragma[nomagic]
+    predicate hasUnknownReturnTypeAt(TypePath path) {
+      exists(Constructor c, TypeParameter tp |
+        c = this.getTarget() and
+        tp = c.getReturnType(path) and
+        not tp = c.getParameterType(_, _) and
+        // check that no explicit type arguments have been supplied for `tp`
+        not exists(TypeArgumentPosition tapos |
+          this.getTypeArgument(tapos, _) != TUnknownType() and
+          TTypeParamTypeParameter(tapos.asTypeParam()) = tp
+        )
+      )
+    }
+  }
+
+  private class NonAssocCallConstruction extends Construction, NonAssocCallExpr,
+    ContextualTyping::ContextuallyTypedCallCand
+  {
+    NonAssocCallConstruction() {
+      this instanceof CallExprImpl::TupleStructExpr or
+      this instanceof CallExprImpl::TupleVariantExpr
+    }
+
+    override Type getTypeArgument(TypeArgumentPosition apos, TypePath path) {
+      result = NonAssocCallExpr.super.getTypeArgument(apos, path)
+    }
+
+    override AstNode getArgument(int i) {
+      exists(FunctionPosition pos |
+        i = pos.asPosition() and
+        result = NonAssocCallExpr.super.getNodeAt(pos)
+      )
+    }
+
+    override Constructor getTarget() { result = this.resolveCallTargetViaPathResolution() }
+  }
+
+  abstract private class StructConstruction extends Construction instanceof PathAstNode {
+    pragma[nomagic]
+    override Constructor getTarget() { result = resolvePath(super.getPath()) }
+
+    pragma[nomagic]
+    override Type getTypeArgument(TypeArgumentPosition apos, TypePath path) {
+      // Handle constructions that use `Self {...}` syntax
+      exists(TypeMention tm, TypePath path0 |
+        tm = super.getPath() and
+        result = tm.getTypeAt(path0) and
+        path0.isCons(TTypeParamTypeParameter(apos.asTypeParam()), path)
+      )
+    }
+  }
+
+  private class StructExprConstruction extends StructConstruction, StructExpr {
+    override Type getTypeArgument(TypeArgumentPosition apos, TypePath path) {
+      result = super.getTypeArgument(apos, path)
+      or
+      exists(TypePath suffix |
+        suffix.isCons(TTypeParamTypeParameter(apos.asTypeParam()), path) and
+        result = inferTypeCertain(this, suffix)
+      )
+    }
+
+    override AstNode getArgument(int i) {
+      result =
+        this.getFieldExpr(pragma[only_bind_into](this.getNthStructField(i).getName().getText()))
+            .getExpr()
+    }
+  }
+
+  /** A potential nullary struct/variant construction such as `None`. */
+  private class PathExprConstruction extends StructConstruction, PathExpr {
+    PathExprConstruction() { not exists(CallExpr ce | this = ce.getFunction()) }
+
+    override AstNode getArgument(int i) { none() }
+  }
+
   predicate inferStepCertain(AstNode n1, TypePath path1, AstNode n2, TypePath path2) {
     n1 =
       any(IdentPat ip |
@@ -756,8 +887,6 @@ private module Input3 implements InputSig3 {
     or
     result = inferAssignmentOperationType(n, path)
     or
-    exists(FunctionPosition pos | pos.isReturn() | result = inferConstructionType(n, pos, path))
-    or
     result = inferTryExprType(n, path)
     or
     result = inferLiteralType(n, path, false)
@@ -776,10 +905,6 @@ private module Input3 implements InputSig3 {
     or
     result = inferUnknownType(n, path)
   }
-
-  Type inferTypeTopDown(AstNode n, TypePath path) {
-    exists(FunctionPosition pos | not pos.isReturn() | result = inferConstructionType(n, pos, path))
-  }
 }
 
 private module M3 = Make3<Input3>;
@@ -3008,172 +3133,6 @@ private Type inferFunctionCallSelfArgumentTypeContextual(
   )
 }
 
-abstract private class Constructor extends Addressable {
-  final TypeParameter getTypeParameter(TypeParameterPosition ppos) {
-    result = ppos.asTypeParameter() and
-    ppos.asTypeParam() = this.getTypeItem().getGenericParamList().getATypeParam()
-  }
-
-  abstract TypeItem getTypeItem();
-
-  abstract TypeRepr getParameterTypeRepr(int pos);
-
-  Type getParameterType(int pos, TypePath path) {
-    result = this.getParameterTypeRepr(pos).(TypeMention).getTypeAt(path)
-  }
-
-  Type getReturnType(TypePath path) {
-    result = TDataType(this.getTypeItem()) and
-    path.isEmpty()
-    or
-    result = TTypeParamTypeParameter(this.getTypeItem().getGenericParamList().getATypeParam()) and
-    path = TypePath::singleton(result)
-  }
-
-  Type getDeclaredType(FunctionPosition pos, TypePath path) {
-    result = this.getParameterType(pos.asPosition(), path)
-    or
-    pos.isReturn() and
-    result = this.getReturnType(path)
-  }
-}
-
-private class StructConstructor extends Constructor instanceof Struct {
-  override TypeItem getTypeItem() { result = this }
-
-  override TypeRepr getParameterTypeRepr(int i) {
-    result = [super.getTupleField(i).getTypeRepr(), super.getNthStructField(i).getTypeRepr()]
-  }
-}
-
-private class VariantConstructor extends Constructor instanceof Variant {
-  override TypeItem getTypeItem() { result = super.getEnum() }
-
-  override TypeRepr getParameterTypeRepr(int i) {
-    result = [super.getTupleField(i).getTypeRepr(), super.getNthStructField(i).getTypeRepr()]
-  }
-}
-
-/**
- * A matching configuration for resolving types of constructions of enums and
- * structs, such as `Result::Ok(42)`, `Foo { bar: 1 }` and `None`.
- */
-private module ConstructionMatchingInput implements MatchingInputSig {
-  import FunctionPositionMatchingInput
-
-  class Declaration = Constructor;
-
-  abstract class Access extends AstNode {
-    abstract Type getInferredType(FunctionPosition pos, TypePath path);
-
-    abstract Declaration getTarget();
-
-    abstract AstNode getNodeAt(AccessPosition apos);
-
-    abstract Type getTypeArgument(TypeArgumentPosition apos, TypePath path);
-
-    /**
-     * Holds if the return type of this construction expression at `path` may
-     * have to be inferred from the context. For example in `Result::Ok(42)` the
-     * error type has to be inferred from the context.
-     */
-    pragma[nomagic]
-    predicate hasUnknownTypeAt(FunctionPosition pos, TypePath path) {
-      exists(Declaration d, TypeParameter tp |
-        d = this.getTarget() and
-        pos.isReturn() and
-        tp = d.getReturnType(path) and
-        not exists(FunctionPosition pos2 | not pos2.isReturn() and tp = d.getDeclaredType(pos2, _)) and
-        // check that no explicit type arguments have been supplied for `tp`
-        not exists(TypeArgumentPosition tapos |
-          this.getTypeArgument(tapos, _) != TUnknownType() and
-          TTypeParamTypeParameter(tapos.asTypeParam()) = tp
-        )
-      )
-    }
-  }
-
-  private class NonAssocCallAccess extends Access, NonAssocCallExpr,
-    ContextualTyping::ContextuallyTypedCallCand
-  {
-    NonAssocCallAccess() {
-      this instanceof CallExprImpl::TupleStructExpr or
-      this instanceof CallExprImpl::TupleVariantExpr
-    }
-
-    override Type getTypeArgument(TypeArgumentPosition apos, TypePath path) {
-      result = NonAssocCallExpr.super.getTypeArgument(apos, path)
-    }
-
-    override AstNode getNodeAt(AccessPosition apos) {
-      result = NonAssocCallExpr.super.getNodeAt(apos)
-    }
-
-    override Type getInferredType(FunctionPosition pos, TypePath path) {
-      result = NonAssocCallExpr.super.getInferredType(pos, path)
-    }
-
-    override Declaration getTarget() { result = this.resolveCallTargetViaPathResolution() }
-  }
-
-  abstract private class StructAccess extends Access instanceof PathAstNode {
-    pragma[nomagic]
-    override Type getInferredType(AccessPosition apos, TypePath path) {
-      result = inferType(this.getNodeAt(apos), path)
-    }
-
-    pragma[nomagic]
-    override Declaration getTarget() { result = resolvePath(super.getPath()) }
-
-    pragma[nomagic]
-    override Type getTypeArgument(TypeArgumentPosition apos, TypePath path) {
-      // Handle constructions that use `Self {...}` syntax
-      exists(TypeMention tm, TypePath path0 |
-        tm = super.getPath() and
-        result = tm.getTypeAt(path0) and
-        path0.isCons(TTypeParamTypeParameter(apos.asTypeParam()), path)
-      )
-    }
-  }
-
-  private class StructExprAccess extends StructAccess, StructExpr {
-    override Type getTypeArgument(TypeArgumentPosition apos, TypePath path) {
-      result = super.getTypeArgument(apos, path)
-      or
-      exists(TypePath suffix |
-        suffix.isCons(TTypeParamTypeParameter(apos.asTypeParam()), path) and
-        result = inferTypeCertain(this, suffix)
-      )
-    }
-
-    override AstNode getNodeAt(AccessPosition apos) {
-      result =
-        this.getFieldExpr(pragma[only_bind_into](this.getNthStructField(apos.asPosition())
-              .getName()
-              .getText())).getExpr()
-      or
-      result = this and apos.isReturn()
-    }
-  }
-
-  /** A potential nullary struct/variant construction such as `None`. */
-  private class PathExprAccess extends StructAccess, PathExpr {
-    PathExprAccess() { not exists(CallExpr ce | this = ce.getFunction()) }
-
-    override AstNode getNodeAt(AccessPosition apos) { result = this and apos.isReturn() }
-  }
-}
-
-private module ConstructionMatching = Matching<ConstructionMatchingInput>;
-
-pragma[nomagic]
-private Type inferConstructionType(AstNode n, FunctionPosition pos, TypePath path) {
-  exists(ConstructionMatchingInput::Access a |
-    n = a.getNodeAt(pos) and
-    result = ConstructionMatching::inferAccessType(a, pos, path)
-  )
-}
-
 pragma[nomagic]
 private Type inferUnknownType(AstNode n, TypePath path) {
   result = TUnknownType() and
@@ -3183,10 +3142,7 @@ private Type inferUnknownType(AstNode n, TypePath path) {
       call.hasUnknownTypeAt(_, pos, path)
     )
     or
-    exists(ConstructionMatchingInput::Access a, FunctionPosition pos |
-      n = a.getNodeAt(pos) and
-      a.hasUnknownTypeAt(pos, path)
-    )
+    n.(Input3::Construction).hasUnknownReturnTypeAt(path)
     or
     exists(Param p |
       not p.hasTypeRepr() and
@@ -3452,7 +3408,14 @@ private Type inferDereferencedExprPtrType(AstNode n, TypePath path) {
 private module DeconstructionPatMatchingInput implements MatchingInputSig {
   import FunctionPositionMatchingInput
 
-  class Declaration = ConstructionMatchingInput::Declaration;
+  class Declaration extends Input3::Constructor {
+    Type getDeclaredType(FunctionPosition pos, TypePath path) {
+      result = this.getParameterType(pos.asPosition(), path)
+      or
+      pos.isReturn() and
+      result = this.getReturnType(path)
+    }
+  }
 
   class Access extends Pat instanceof PathAstNode {
     Access() { this instanceof TupleStructPat or this instanceof StructPat }