diff --git a/sema/subtype_check.gen.go b/sema/subtype_check.gen.go index 847c7ad95..d0e091de5 100644 --- a/sema/subtype_check.gen.go +++ b/sema/subtype_check.gen.go @@ -306,7 +306,7 @@ func checkSubTypeWithoutEquality_gen(subType Type, superType Type) bool { return AreTypeParamsEqual(typedSubType, typedSuperType) && (AreParamsContravariant(typedSubType, typedSuperType) && (AreReturnsCovariant(typedSubType, typedSuperType) && - AreConstructorsEqual(typedSubType, typedSuperType))) + typedSubType.IsConstructor == typedSuperType.IsConstructor)) } } diff --git a/sema/subtype_check.go b/sema/subtype_check.go index b5eb69abd..b20ae09bc 100644 --- a/sema/subtype_check.go +++ b/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() diff --git a/sema/type.go b/sema/type.go index 1803a807c..c322a8040 100644 --- a/sema/type.go +++ b/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: diff --git a/tools/subtype-gen/README.md b/tools/subtype-gen/README.md index fb04cdec7..82cc3215a 100644 --- a/tools/subtype-gen/README.md +++ b/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`) diff --git a/tools/subtype-gen/generator.go b/tools/subtype-gen/generator.go index 6545e3725..ad33f36c3 100644 --- a/tools/subtype-gen/generator.go +++ b/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), diff --git a/tools/subtype-gen/predicates.go b/tools/subtype-gen/predicates.go index eb48da85a..0cd3b8b3e 100644 --- a/tools/subtype-gen/predicates.go +++ b/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{} diff --git a/tools/subtype-gen/rules.yaml b/tools/subtype-gen/rules.yaml index 1e79559e8..ae7b92316 100644 --- a/tools/subtype-gen/rules.yaml +++ b/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: diff --git a/tools/subtype-gen/rules_parser.go b/tools/subtype-gen/rules_parser.go index b6db16541..61e673820 100644 --- a/tools/subtype-gen/rules_parser.go +++ b/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