Make plan.Section() simpler - no reflection

internals/plan/extensions_test.go

@@ -381,15 +381,15 @@ func (s *S) TestPlanExtensions(c *C) {
 			if _, ok := planTest.extensions[xField]; ok {
 				// Verify "x-field" data.
 				var x *xSection
-				err = p.Section(xField, &x)
+				x = p.Section(xField).(*xSection)
 				c.Assert(err, IsNil)
 				c.Assert(x.Entries, DeepEquals, planTest.combinedPlanResult.x.Entries)
 			}
 
 			if _, ok := planTest.extensions[yField]; ok {
 				// Verify "y-field" data.
 				var y *ySection
-				err = p.Section(yField, &y)
+				y = p.Section(yField).(*ySection)
 				c.Assert(err, IsNil)
 				c.Assert(y.Entries, DeepEquals, planTest.combinedPlanResult.y.Entries)
 			}
@@ -451,19 +451,10 @@ func (x xExtension) CombineSections(sections ...plan.LayerSection) (plan.LayerSe
 
 func (x xExtension) ValidatePlan(p *plan.Plan) error {
 	var xs *xSection
-	err := p.Section(xField, &xs)
-	if err != nil {
-		return err
-	}
+	xs = p.Section(xField).(*xSection)
 	if xs != nil {
 		var ys *ySection
-		err = p.Section(yField, &ys)
-		if err != nil {
-			return err
-		}
-		if ys == nil {
-			return fmt.Errorf("cannot validate %v field without %v field", xField, yField)
-		}
+		ys = p.Section(yField).(*ySection)
 
 		// Test dependency: Make sure every Y field in X refer to an existing Y entry.
 		for xEntryField, xEntryValue := range xs.Entries {

internals/plan/plan.go

@@ -96,29 +96,8 @@ type Plan struct {
 }
 
 // Section retrieves a section from the plan.
-func (p *Plan) Section(field string, out interface{}) error {
-	if _, found := layerExtensions[field]; !found {
-		return fmt.Errorf("cannot find registered extension for field %q", field)
-	}
-
-	outVal := reflect.ValueOf(out)
-	if outVal.Kind() != reflect.Ptr || outVal.IsNil() {
-		return fmt.Errorf("cannot read non pointer to section type %q", outVal.Kind())
-	}
-
-	section, exists := p.Sections[field]
-	if !exists {
-		return fmt.Errorf("internal error: section %q is nil", field)
-	}
-
-	sectionVal := reflect.ValueOf(section)
-	sectionType := sectionVal.Type()
-	outValPtrType := outVal.Elem().Type()
-	if !sectionType.AssignableTo(outValPtrType) {
-		return fmt.Errorf("cannot assign value of type %s to out argument of type %s", sectionType, outValPtrType)
-	}
-	outVal.Elem().Set(sectionVal)
-	return nil
+func (p *Plan) Section(field string) LayerSection {
+	return p.Sections[field]
 }
 
 // MarshalYAML implements an override for top level omitempty tags handling.