Dyno: initial implementation of checking (explicit) interface constraints

compiler/passes/convert-typed-uast.cpp

@@ -1485,6 +1485,18 @@ Type* TConverter::helpConvertType(const types::Type* t) {
     case typetags::CPtrType:       return helpConvertPtrType(t->toPtrType());
     case typetags::HeapBufferType: return helpConvertPtrType(t->toPtrType());
 
+    // Interfaces require something clever (creating a constrained generic
+    // function), and we don't have that yet.
+    case typetags::InterfaceType:
+      CHPL_UNIMPL("convert interface type");
+      return dtUnknown; // TODO
+
+    // placeholders only occur in interface resolution and should not be
+    // reachable
+    case typetags::PlaceholderType:
+      INT_FATAL("should not be reachable");
+      return dtUnknown;
+
     // implementation detail tags (should not be reachable)
     case typetags::START_ManageableType:
     case typetags::END_ManageableType:

frontend/include/chpl/parsing/parsing-queries.h

@@ -521,6 +521,11 @@ bool idIsPrivateDecl(Context* context, ID id);
  */
 bool idIsFunction(Context* context, ID id);
 
+/**
+ Returns true if the ID is an interface
+ */
+bool idIsInterface(Context* context, ID id);
+
 /**
  Returns true if the ID is marked 'extern'.
  */
@@ -557,6 +562,11 @@ const ID& idToParentId(Context* context, ID id);
  */
 ID idToParentFunctionId(Context* context, ID id);
 
+/**
+ Returns the parent interface ID given an ID.
+ */
+ID idToParentInterfaceId(Context* context, ID id);
+
 /**
  Returns the parent AST node given an AST node
  */

frontend/include/chpl/resolution/ResolutionContext.h

@@ -40,6 +40,7 @@ class ResolvedFunction;
 class TypedFnSignature;
 class UntypedFnSignature;
 class MatchingIdsWithName;
+class ImplementationWitness;
 
 /**
   This class is used to manage stack frames that may be necessary while
@@ -113,7 +114,7 @@ class ResolutionContext {
       when they are destroyed. */
   class Frame {
    public:
-    enum Kind { FUNCTION, MODULE, UNKNOWN };
+    enum Kind { FUNCTION, MODULE, INTERFACE, UNKNOWN };
 
    private:
     friend class ResolutionContext;
@@ -126,6 +127,8 @@ class ResolutionContext {
 
     Resolver* rv_ = nullptr;
     const ResolvedFunction* rf_ = nullptr;
+    const types::InterfaceType* ift_ = nullptr;
+    const ImplementationWitness* witness_ = nullptr;
     int64_t index_ = BASE_FRAME_INDEX;
     Store cachedResults_;
     Kind kind_ = UNKNOWN;
@@ -137,6 +140,9 @@ class ResolutionContext {
     Frame(const ResolvedFunction* rf, int64_t index)
       : rf_(rf), index_(index), kind_(FUNCTION) {
     }
+    Frame(const types::InterfaceType* ift, const ImplementationWitness* witness, int64_t index)
+      : ift_(ift), witness_(witness), index_(index), kind_(INTERFACE) {
+    }
 
    public:
    ~Frame() = default;
@@ -155,12 +161,14 @@ class ResolutionContext {
     }
 
     Resolver* rv() { return rv_; }
-    const ResolvedFunction* rf() { return rf_; }
+    const ResolvedFunction* rf() const { return rf_; }
+    const types::InterfaceType* ift() const { return ift_; }
+    const ImplementationWitness* witness() const { return witness_; }
 
     bool isEmpty() { return !rv() && !rf(); }
     const ID& id() const;
     const TypedFnSignature* signature() const;
-    const ResolutionResultByPostorderID* resolutionById() const;
+    const types::QualifiedType typeForContainedId(ResolutionContext* rc, const ID& id) const;
     bool isUnstable() const;
 
     template <typename T>
@@ -183,6 +191,7 @@ class ResolutionContext {
   Frame baseFrame_;
 
   const Frame* pushFrame(const ResolvedFunction* rf);
+  const Frame* pushFrame(const types::InterfaceType* t, const ImplementationWitness* witness);
   const Frame* pushFrame(Resolver* rv, Frame::Kind kind);
   void popFrame(const ResolvedFunction* rf);
   void popFrame(Resolver* rv);

frontend/include/chpl/resolution/can-pass.h

@@ -204,6 +204,17 @@ CanPassResult canPassScalar(Context* context,
   return CanPassResult::canPassScalar(context, actualType, formalType);
 }
 
+/* Returns true if, all other things equal, a type with substitutions
+   'instances' is an instantiation of a type with substitutions 'generics'.
+
+   If 'allowMissing' is true, considers missing substitutions in 'generics'
+   to be "any type". Otherwise, requires that each susbtitution in
+   instances is matched by an existing substitution in generics. */
+bool canInstantiateSubstitutions(Context* context,
+                                 const SubstitutionsMap& instances,
+                                 const SubstitutionsMap& generics,
+                                 bool allowMissing);
+
 /* When trying to combine two kinds, you can't just pick one.
    For instance, if any type in the list is a value, the result
    should be a value, and if any type in the list is const, the

frontend/include/chpl/resolution/interface-types.h

@@ -0,0 +1,184 @@
+/*
+ * Copyright 2024 Hewlett Packard Enterprise Development LP
+ * Other additional copyright holders may be indicated within.
+ *
+ * The entirety of this work is licensed under the Apache License,
+ * Version 2.0 (the "License"); you may not use this file except
+ * in compliance with the License.
+ *
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef CHPL_RESOLUTION_INTERFACE_TYPES_H
+#define CHPL_RESOLUTION_INTERFACE_TYPES_H
+
+#include "chpl/framework/ID.h"
+#include "chpl/framework/update-functions.h"
+#include "chpl/types/InterfaceType.h"
+#include "chpl/util/hash.h"
+
+namespace chpl {
+namespace resolution {
+
+/*
+  Represent a resolved form of an 'implements'-like statement, which asserts
+  that a (possibly-generic) list of types satisfies an interface. All
+  of the following are transformed into implementation points:
+
+    record R : I {}
+    implements R(I);
+    R implements I;
+
+  The types of the "actuals" (R in the above examples) are stored as substitutions
+  for the InterfaceType. This means that in the case of a concrete implementation
+  point, its interface() will be equal to constraint being searched for.
+ */
+class ImplementationPoint {
+ private:
+  // The interface being implemented (instantiated with the types of the arguments)
+  const types::InterfaceType* interface_;
+  // The ID of the implementation statement
+  ID id_;
+
+  ImplementationPoint(const types::InterfaceType* interface,
+                      ID id)
+    : interface_(interface), id_(id) {}
+
+  static owned<ImplementationPoint> const&
+  getImplementationPoint(Context* context,
+                         const types::InterfaceType* interface,
+                         ID id);
+
+ public:
+  static const ImplementationPoint*
+  get(Context* context, const types::InterfaceType* interface, ID id);
+
+  static bool update(owned<ImplementationPoint>& lhs,
+                     owned<ImplementationPoint>& rhs) {
+    return defaultUpdateOwned(lhs, rhs);
+  }
+  bool operator==(const ImplementationPoint& other) const {
+    return interface_ == other.interface_ &&
+           id_ == other.id_;
+  }
+  bool operator!=(const ImplementationPoint& other) const {
+    return !(*this == other);
+  }
+  void mark(Context* context) const;
+  void stringify(std::ostream& ss, chpl::StringifyKind stringKind) const;
+
+  /* get the (possibly-generic) interface being implemented, which includes
+     substitutions from the actuals. */
+  const types::InterfaceType* interface() const { return interface_; }
+
+  /* get the ID of the implementation point (statement or inheritance expression) */
+  const ID& id() const { return id_; }
+};
+
+/*
+   Represents evidence that a particular type or list of types implements
+   a given interface. This includes:
+
+   * associated constraints (e.g., a 'totalOrder' interface requires a
+     'partialOrder' interface to be satisfied).
+   * associated types (e.g., a 'collection' interface requires a 'Element'
+     type to be defined; in the standard library, the 'contextManager' interface
+     specifies the type of the underlying resource).
+   * required functions (e.g., a 'hashable' interface requires a 'hash' function
+     to be defined).
+ */
+class ImplementationWitness {
+ public:
+  using ConstraintMap = std::unordered_map<ID, const ImplementationWitness*>;
+  using AssociatedTypeMap = types::PlaceholderMap;
+  using FunctionMap = std::unordered_map<ID, ID>;
+
+ private:
+
+  ConstraintMap associatedConstraints_;
+  AssociatedTypeMap associatedTypes_;
+  FunctionMap requiredFns_;
+
+  ImplementationWitness(ConstraintMap associatedConstraints,
+                        AssociatedTypeMap associatedTypes,
+                        FunctionMap requiredFns)
+    : associatedConstraints_(std::move(associatedConstraints)),
+      associatedTypes_(std::move(associatedTypes)),
+      requiredFns_(std::move(requiredFns)) {}
+
+  static const owned<ImplementationWitness>&
+  getImplementationWitness(Context* context,
+                           ConstraintMap associatedConstraints,
+                           AssociatedTypeMap associatedTypes,
+                           FunctionMap requiredFns);
+
+ public:
+  static ImplementationWitness*
+  get(Context* context,
+      ConstraintMap associatedConstraints,
+      AssociatedTypeMap associatedTypes,
+      FunctionMap requiredFns);
+
+  static bool update(owned<ImplementationWitness>& lhs,
+                     owned<ImplementationWitness>& rhs) {
+    return defaultUpdateOwned(lhs, rhs);
+  }
+  bool operator==(const ImplementationWitness& other) const {
+    return associatedConstraints_ == other.associatedConstraints_ &&
+           associatedTypes_ == other.associatedTypes_ &&
+           requiredFns_ == other.requiredFns_;
+  }
+  bool operator!=(const ImplementationWitness& other) const {
+    return !(*this == other);
+  }
+  void mark(Context* context) const {
+    chpl::mark<decltype(associatedTypes_)>{}(context, associatedTypes_);
+    chpl::mark<decltype(requiredFns_)>{}(context, requiredFns_);
+    chpl::mark<decltype(associatedConstraints_)>{}(context, associatedConstraints_);
+  }
+  void stringify(std::ostream& ss, chpl::StringifyKind stringKind) const;
+
+  /** Get the associated constraints. */
+  const ConstraintMap& associatedConstraints() const {
+    return associatedConstraints_;
+  }
+
+  /** Get the associated types. */
+  const AssociatedTypeMap& associatedTypes() const {
+    return associatedTypes_;
+  }
+
+  /** Get the required functions. */
+  const FunctionMap& requiredFns() const {
+    return requiredFns_;
+  }
+};
+
+} // end namespace resolution
+} // end namespace chpl
+
+
+namespace std {
+
+template<> struct hash<chpl::resolution::ImplementationWitness::ConstraintMap> {
+  size_t operator()(const chpl::resolution::ImplementationWitness::ConstraintMap& key) const {
+    return chpl::hashUnorderedMap(key);
+  }
+};
+
+template<> struct hash<chpl::resolution::ImplementationWitness::FunctionMap> {
+  size_t operator()(const chpl::resolution::ImplementationWitness::FunctionMap& key) const {
+    return chpl::hashUnorderedMap(key);
+  }
+};
+
+}
+#endif

frontend/include/chpl/resolution/resolution-error-classes-list.h

@@ -55,8 +55,18 @@ ERROR_CLASS(IncompatibleKinds, types::QualifiedType::Kind, const uast::AstNode*,
 ERROR_CLASS(IncompatibleRangeBounds, const uast::Range*, types::QualifiedType, types::QualifiedType)
 ERROR_CLASS(IncompatibleTypeAndInit, const uast::AstNode*, const uast::AstNode*, const uast::AstNode*, const types::Type*, const types::Type*)
 ERROR_CLASS(IncompatibleYieldTypes, const uast::AstNode*, std::vector<std::tuple<uast::Function::IteratorKind, types::QualifiedType, const resolution::TypedFnSignature*>>)
+ERROR_CLASS(InterfaceAmbiguousFn, const types::InterfaceType*, ID, const uast::Function*, std::vector<const resolution::TypedFnSignature*>)
+ERROR_CLASS(InterfaceInvalidIntent, const types::InterfaceType*, ID, const resolution::TypedFnSignature*, const resolution::TypedFnSignature*)
+ERROR_CLASS(InterfaceMissingAssociatedType, const types::InterfaceType*, ID, const uast::Variable*, resolution::CallInfo, std::vector<resolution::ApplicabilityResult>)
+ERROR_CLASS(InterfaceMissingFn, const types::InterfaceType*, ID, const resolution::TypedFnSignature*, resolution::CallInfo, std::vector<resolution::ApplicabilityResult>)
+ERROR_CLASS(InterfaceMultipleImplements, const uast::AggregateDecl*, const types::InterfaceType*, ID, ID)
+ERROR_CLASS(InterfaceNaryInInherits, const uast::AggregateDecl*, const types::InterfaceType*, ID)
+ERROR_CLASS(InterfaceReorderedFnFormals, const types::InterfaceType*, ID, const resolution::TypedFnSignature*, const resolution::TypedFnSignature*)
 ERROR_CLASS(InvalidClassCast, const uast::PrimCall*, types::QualifiedType)
 ERROR_CLASS(InvalidDomainCall, const uast::FnCall*, std::vector<types::QualifiedType>)
+ERROR_CLASS(InvalidImplementsActual, const uast::Implements*, const uast::AstNode*, types::QualifiedType)
+ERROR_CLASS(InvalidImplementsArity, const uast::Implements*, const types::InterfaceType*, std::vector<types::QualifiedType>)
+ERROR_CLASS(InvalidImplementsInterface, const uast::Implements*, types::QualifiedType)
 ERROR_CLASS(InvalidIndexCall, const uast::FnCall*, types::QualifiedType)
 ERROR_CLASS(InvalidNewTarget, const uast::New*, types::QualifiedType)
 ERROR_CLASS(InvalidParamCast, const uast::AstNode*, types::QualifiedType, types::QualifiedType)
@@ -71,6 +81,7 @@ ERROR_CLASS(MultipleInheritance, const uast::Class*, const uast::AstNode*, const
 ERROR_CLASS(MultipleQuestionArgs, const uast::FnCall*, const uast::AstNode*, const uast::AstNode*)
 ERROR_CLASS(NestedClassFieldRef, const uast::TypeDecl*, const uast::TypeDecl*, const uast::AstNode*, ID)
 ERROR_CLASS(NoMatchingCandidates, const uast::AstNode*, resolution::CallInfo, std::vector<resolution::ApplicabilityResult>)
+ERROR_CLASS(NonClassInheritance, const uast::AggregateDecl*, const uast::AstNode*, const types::Type*)
 ERROR_CLASS(NonIterable, const uast::AstNode*, const uast::AstNode*, types::QualifiedType, std::vector<std::tuple<uast::Function::IteratorKind, chpl::resolution::TheseResolutionResult>>)
 ERROR_CLASS(NoMatchingEnumValue, const uast::AstNode*, const types::EnumType*, types::QualifiedType)
 ERROR_CLASS(NotInModule, const uast::Dot*, ID, UniqueString, ID, bool)