Initial obsolete conformance

Author: hasty

matter/conformance/conformance_test.go

@@ -456,6 +456,18 @@ var conformanceTests = []conformanceTestSuite{
 		Conformance:        "AA | [BB]",
 		InvalidConformance: true,
 	},
+	{
+		Conformance:        "AA, P",
+		InvalidConformance: true,
+	},
+	{
+		Conformance:        "D",
+		InvalidConformance: true,
+	},
+	{
+		Conformance:        "AA, D, [BB]",
+		InvalidConformance: true,
+	},
 	{
 		Conformance: "AA, [BB]",
 		Tests: []conformanceTest{

matter/conformance/grammar/conformance.peg

@@ -20,16 +20,31 @@ Input <- conf:Conformance+ EOF {
     cs := conf.([]interface{})
 
     var set Set
-    for _, i := range cs {
-        con := i.(Conformance)
+    for i, e := range cs {
+        con := e.(Conformance)
+        switch con.(type) {
+            case *Provisional:
+                if i != 0 {
+                    return nil, fmt.Errorf("provisionality set at index %d; provisional annotations must be the first element of conformance", i)
+                }
+            case *Deprecated:
+                if i == 0 || i != len(cs) - 1 {
+                    return nil, fmt.Errorf("deprecation set at index %d; deprecation annotations must be the last element in a set of conformances", i)
+                }
+            case *Obsolete:
+                if i != len(cs) - 1 {
+                    return nil, fmt.Errorf("obsolete set at index %d; obsolete annotations must appear alone, or be the last element in a set of conformances", i)
+                }
+            
+        }
         set = append(set, con)
     }
     return set, nil
 }
 
 ConformanceSeparator <- (_ Comma _) / &EOF
 
-Conformance <-  '[' i:Expression ']' choice:Choice? ConformanceSeparator {
+Conformance <-  '[' i:LogicalExpression ']' choice:Choice? ConformanceSeparator {
     exp := i.(Expression)
     o := &Optional{Expression:exp}
     if choice != nil {
@@ -51,14 +66,15 @@ Conformance <-  '[' i:Expression ']' choice:Choice? ConformanceSeparator {
     return &Deprecated{}, nil
 } / 'X'  ConformanceSeparator {
     return &Disallowed{}, nil
+} / 'Z'  ConformanceSeparator {
+    return &Obsolete{}, nil
+}
 } / "desc"  ConformanceSeparator { 
      return &Described{}, nil
-} / eq:Expression ConformanceSeparator {
+} / eq:LogicalExpression ConformanceSeparator {
     exp := eq.(Expression)
     return &Mandatory{Expression:exp}, nil
 }
 
-Expression <- LogicalExpression 
-
 
 

matter/conformance/grammar/logical.peg

@@ -58,7 +58,7 @@ AndOp <- _ "&" _ f:LogicalTerm {
     return fc, nil
 }
 
-LogicalTerm <- not:'!'? '(' _  eq:Expression _ ')' {
+LogicalTerm <- not:'!'? '(' _  eq:LogicalExpression _ ')' {
     //debug("matched feature term %s\n", string(c.text))
     if not != nil {
         switch eq := eq.(type) {

matter/conformance/obsolete.go

@@ -0,0 +1,34 @@
+package conformance
+
+type Obsolete struct {
+	raw string
+}
+
+func (d *Obsolete) Type() Type {
+	return TypeDeprecated
+}
+
+func (d *Obsolete) RawText() string {
+	return d.raw
+}
+
+func (d *Obsolete) ASCIIDocString() string {
+	return "Z"
+}
+
+func (d *Obsolete) Description() string {
+	return "obsolete"
+}
+
+func (d *Obsolete) Eval(context Context) (ConformanceState, error) {
+	return ConformanceState{State: StateDeprecated, Confidence: ConfidenceDefinite}, nil
+}
+
+func (d *Obsolete) Equal(c Conformance) bool {
+	_, ok := c.(*Obsolete)
+	return ok
+}
+
+func (d *Obsolete) Clone() Conformance {
+	return &Obsolete{raw: d.raw}
+}