[Subtyping Generator] Improve subtype check generation

sema/subtype_check.go

@@ -104,10 +104,6 @@ func AreReturnsCovariant(source, target *FunctionType) bool {
 	return true
 }
 
-func AreConstructorsEqual(source, target *FunctionType) bool {
-	return source.IsConstructor == target.IsConstructor
-}
-
 func AreTypeArgumentsEqual(source, target ParameterizedType) bool {
 	subTypeTypeArguments := source.TypeArguments()
 	superTypeTypeArguments := target.TypeArguments()

sema/type.go

@@ -7716,7 +7716,7 @@ func checkSubTypeWithoutEquality(subType Type, superType Type) bool {
 			AreReturnsCovariant(typedSubType, typedSuperType) &&
 
 			// Constructors?
-			AreConstructorsEqual(typedSubType, typedSuperType)
+			typedSubType.IsConstructor == typedSuperType.IsConstructor
 
 	case *IntersectionType:
 

tools/subtype-gen/README.md

@@ -119,8 +119,8 @@ e.g:
 
 ```yaml
 - setContains:
-    source: super.EffectiveInterfaceConformanceSet
-    target: sub
+    set: super.EffectiveInterfaceConformanceSet
+    element: sub
 ```
 
 ### Permits Predicate (`permits`)

tools/subtype-gen/generator.go

@@ -776,9 +776,6 @@ func (gen *SubTypeCheckGenerator) generatePredicateInternal(predicate Predicate)
 	case ReturnCovariantPredicate:
 		return gen.returnsCovariantCheck(p)
 
-	case ConstructorEqualPredicate:
-		return gen.constructorsEqualCheck(p)
-
 	case TypeArgumentsEqualPredicate:
 		return gen.typeAegumentsEqualCheck(p)
 
@@ -1377,12 +1374,12 @@ func (gen *SubTypeCheckGenerator) newTypedVariableNameFor(source Expression) str
 
 func (gen *SubTypeCheckGenerator) setContains(p SetContainsPredicate) []dst.Node {
 	selectExpr := &dst.SelectorExpr{
-		X:   gen.expressionIgnoreNegation(p.Source),
+		X:   gen.expressionIgnoreNegation(p.Set),
 		Sel: dst.NewIdent("Contains"),
 	}
 
 	args := []dst.Expr{
-		gen.expressionIgnoreNegation(p.Target),
+		gen.expressionIgnoreNegation(p.Element),
 	}
 
 	callExpr := gen.callExpression(selectExpr, args...)
@@ -1448,20 +1445,6 @@ func (gen *SubTypeCheckGenerator) returnsCovariantCheck(p ReturnCovariantPredica
 	}
 }
 
-func (gen *SubTypeCheckGenerator) constructorsEqualCheck(p ConstructorEqualPredicate) []dst.Node {
-	args := []dst.Expr{
-		gen.expressionIgnoreNegation(p.Source),
-		gen.expressionIgnoreNegation(p.Target),
-	}
-
-	return []dst.Node{
-		gen.callExpression(
-			dst.NewIdent("AreConstructorsEqual"),
-			args...,
-		),
-	}
-}
-
 func (gen *SubTypeCheckGenerator) typeAegumentsEqualCheck(p TypeArgumentsEqualPredicate) []dst.Node {
 	args := []dst.Expr{
 		gen.expressionIgnoreNegation(p.Source),

tools/subtype-gen/predicates.go

@@ -160,16 +160,6 @@ var _ Predicate = ReturnCovariantPredicate{}
 
 func (r ReturnCovariantPredicate) isPredicate() {}
 
-// ConstructorEqualPredicate represents a constructor equality check.
-type ConstructorEqualPredicate struct {
-	Source Expression `yaml:"source"`
-	Target Expression `yaml:"target"`
-}
-
-var _ Predicate = ConstructorEqualPredicate{}
-
-func (c ConstructorEqualPredicate) isPredicate() {}
-
 // TypeAssertionPredicate represents a type assertion.
 type TypeAssertionPredicate struct {
 	Source Expression `yaml:"source"`
@@ -181,8 +171,8 @@ var _ Predicate = TypeAssertionPredicate{}
 func (e TypeAssertionPredicate) isPredicate() {}
 
 type SetContainsPredicate struct {
-	Source Expression `yaml:"source"`
-	Target Expression `yaml:"target"`
+	Set     Expression `yaml:"set"`
+	Element Expression `yaml:"element"`
 }
 
 var _ Predicate = SetContainsPredicate{}

tools/subtype-gen/rules.yaml

@@ -258,22 +258,22 @@ rules:
               source: sub.Kind
               target: super.CompositeKind
           - setContains:
-              source: sub.EffectiveInterfaceConformanceSet
-              target: super
+              set: sub.EffectiveInterfaceConformanceSet
+              element: super
         - and:
           - mustType:
               source: sub
               type: IntersectionType
           - setContains:
-              source: sub.EffectiveIntersectionSet
-              target: super
+              set: sub.EffectiveIntersectionSet
+              element: super
         - and:
           - mustType:
               source: sub
               type: InterfaceType
           - setContains:
-              source: sub.EffectiveInterfaceConformanceSet
-              target: super
+              set: sub.EffectiveInterfaceConformanceSet
+              element: super
         - isParameterizedSubtype:
             sub: sub
             super: super
@@ -403,9 +403,9 @@ rules:
         - returnCovariant:
             source: sub
             target: super
-        - constructorEqual:
-            source: sub
-            target: super
+        - equals:
+            source: sub.IsConstructor
+            target: super.IsConstructor
 
   - super: ParameterizedType
     predicate:

tools/subtype-gen/rules_parser.go

@@ -119,19 +119,31 @@ func parsePredicate(predicate any) (Predicate, error) {
 		switch key {
 
 		case "isResource":
-			expr := parseSimpleExpression(value)
+			expr, err := parseExpression(value)
+			if err != nil {
+				return nil, err
+			}
 			return IsResourcePredicate{Expression: expr}, nil
 
 		case "isAttachment":
-			expr := parseSimpleExpression(value)
+			expr, err := parseExpression(value)
+			if err != nil {
+				return nil, err
+			}
 			return IsAttachmentPredicate{Expression: expr}, nil
 
 		case "isHashableStruct":
-			expr := parseSimpleExpression(value)
+			expr, err := parseExpression(value)
+			if err != nil {
+				return nil, err
+			}
 			return IsHashableStructPredicate{Expression: expr}, nil
 
 		case "isStorable":
-			expr := parseSimpleExpression(value)
+			expr, err := parseExpression(value)
+			if err != nil {
+				return nil, err
+			}
 			return IsStorablePredicate{Expression: expr}, nil
 
 		case "equals":
@@ -218,12 +230,15 @@ func parsePredicate(predicate any) (Predicate, error) {
 			}
 
 			// Get source
-			data, ok := keyValues["source"]
+			source, ok := keyValues["source"]
 			if !ok {
 				return nil, fmt.Errorf("cannot find `source` property for `mustType` predicate")
 			}
 
-			sourceExpr := parseSimpleExpression(data)
+			sourceExpr, err := parseExpression(source)
+			if err != nil {
+				return nil, err
+			}
 
 			// Get target
 			typ, ok := keyValues["type"]
@@ -239,14 +254,36 @@ func parsePredicate(predicate any) (Predicate, error) {
 			}, nil
 
 		case "setContains":
-			sourceExpr, targetExpr, err := parseSourceAndTarget(key, value)
+			keyValues, ok := value.(KeyValues)
+			if !ok {
+				return nil, fmt.Errorf("expected KeyValues, got %T", value)
+			}
+
+			// Get the set
+			set, ok := keyValues["set"]
+			if !ok {
+				return nil, fmt.Errorf("cannot find `set` property for `setContains` predicate")
+			}
+
+			setExpr, err := parseExpression(set)
+			if err != nil {
+				return nil, err
+			}
+
+			// Get element
+			element, ok := keyValues["element"]
+			if !ok {
+				return nil, fmt.Errorf("cannot find `element` property for `setContains` predicate")
+			}
+
+			elementExpr, err := parseExpression(element)
 			if err != nil {
 				return nil, err
 			}
 
 			return SetContainsPredicate{
-				Source: sourceExpr,
-				Target: targetExpr,
+				Set:     setExpr,
+				Element: elementExpr,
 			}, nil
 
 		case "isIntersectionSubset":
@@ -293,17 +330,6 @@ func parsePredicate(predicate any) (Predicate, error) {
 				Target: targetExpr,
 			}, nil
 
-		case "constructorEqual":
-			sourceExpr, targetExpr, err := parseSourceAndTarget(key, value)
-			if err != nil {
-				return nil, err
-			}
-
-			return ConstructorEqualPredicate{
-				Source: sourceExpr,
-				Target: targetExpr,
-			}, nil
-
 		case "typeArgumentsEqual":
 			sourceExpr, targetExpr, err := parseSourceAndTarget(key, value)
 			if err != nil {
@@ -346,7 +372,10 @@ func parseSourceAndTarget(predicateName string, value any) (Expression, Expressi
 		return nil, nil, fmt.Errorf("cannot find `source` property for %#q predicate", predicateName)
 	}
 
-	sourceExpr := parseSimpleExpression(source)
+	sourceExpr, err := parseExpression(source)
+	if err != nil {
+		return nil, nil, err
+	}
 
 	// Get target
 	target, ok := keyValues["target"]
@@ -385,7 +414,11 @@ func parseSuperAndSubExpressions(predicateName string, value any) (Expression, E
 		return nil, nil, fmt.Errorf("cannot find `sub` property for %#q predicate", predicateName)
 	}
 
-	subType := parseSimpleExpression(sub)
+	subType, err := parseExpression(sub)
+	if err != nil {
+		return nil, nil, err
+	}
+
 	return superType, subType, nil
 }
 
@@ -417,10 +450,12 @@ func parseExpression(expr any) (Expression, error) {
 
 			var expressions []Expression
 			for _, item := range list {
-				expressions = append(
-					expressions,
-					parseSimpleExpression(item),
-				)
+				itemExpr, err := parseExpression(item)
+				if err != nil {
+					return nil, err
+				}
+
+				expressions = append(expressions, itemExpr)
 			}
 
 			return OneOfExpression{Expressions: expressions}, nil