Fix referencing on data structures - regression

Fix #117

src/RefractDataStructure.cc

@@ -350,6 +350,64 @@ namespace drafter {
  }
  };
 
+
+ template <typename T, typename V = typename T::ValueType>
+ struct ExtractTypeDefinition {
+
+ typedef T ElementType;
+ typedef typename ElementData<T>::ValueCollectionType ValueCollectionType;
+ typedef typename ElementData<T>::ValueSourceMapCollectionType ValueSourceMapCollectionType;
+
+ template<typename X, bool dummy = true>
+ struct InjectNestedTypeInfo {
+ void operator()(const mson::TypeNames&, ValueCollectionType&) {
+ // do nothing
+ }
+ };
+
+ template<bool dummy>
+ struct InjectNestedTypeInfo<RefractElements, dummy> {
+ void operator()(const mson::TypeNames& typeNames, ValueCollectionType& values) {
+ if (typeNames.empty()) {
+ return;
+ }
+
+ RefractElements types;
+ for (mson::TypeNames::const_iterator it = typeNames.begin(); it != typeNames.end(); ++it) {
+ RefractElementFactory& f = FactoryFromType(it->base);
+ types.push_back(f.Create(it->symbol.literal, it->symbol.variable));
+ }
+
+ values.push_back(types);
+ }
+ };
+
+ template<typename X, bool dummy = true>
+ struct InjectNestedTypeInfoSourceMaps {
+ void operator()(const mson::TypeNames&, ValueSourceMapCollectionType&) {
+ }
+ };
+
+ template<bool dummy>
+ struct InjectNestedTypeInfoSourceMaps<RefractElements, dummy> {
+ void operator()(const mson::TypeNames& typeNames, ValueSourceMapCollectionType& values) {
+ if (typeNames.empty()) {
+ return;
+ }
+
+ values.push_back(NodeInfo<typename T::ValueType>::NullSourceMap());
+ }
+ };
+
+ ElementData<ElementType>& data;
+ ExtractTypeDefinition(ElementData<ElementType>& data) : data(data) {}
+
+ void operator()(const NodeInfo<mson::TypeDefinition>& typeDefinition) {
+ InjectNestedTypeInfo<typename T::ValueType>()(typeDefinition.node.typeSpecification.nestedTypes, data.values);
+ InjectNestedTypeInfoSourceMaps<typename T::ValueType>()(typeDefinition.node.typeSpecification.nestedTypes, data.valuesSourceMap);
+ }
+ };
+
  template <typename T, typename V = typename T::ValueType>
  struct ExtractValueMember
  { 
@@ -453,6 +511,7 @@ namespace drafter {
  }
  };
 
+ /*
  template<typename X, bool dummy = true>
  struct InjectNestedTypeInfoSourceMaps {
  void operator()(const NodeInfo<mson::ValueMember>&, ValueSourceMapCollectionType&) {
@@ -476,6 +535,7 @@ namespace drafter {
  }
  }
  };
+ */
 
  template<typename Y, bool dummy = true>
  struct IsValueVariable {
@@ -519,9 +579,12 @@ namespace drafter {
  data.descriptionsSourceMap.push_back(valueMember.sourceMap.description);
  }
 
- if (valueMember.node.valueDefinition.values.empty() || (valueMember.node.valueDefinition.typeDefinition.typeSpecification.nestedTypes.size() > 1)) {
- InjectNestedTypeInfo<typename T::ValueType>()(valueMember, data.values);
- InjectNestedTypeInfoSourceMaps<typename T::ValueType>()(valueMember, data.valuesSourceMap);
+ if ((valueMember.node.valueDefinition.values.empty() || 
+ (valueMember.node.valueDefinition.typeDefinition.typeSpecification.nestedTypes.size() > 1)) &&
+ (GetType(valueMember.node.valueDefinition) != mson::EnumTypeName)) {
+
+ ExtractTypeDefinition<T> extd(data);
+ extd(MakeNodeInfoWithoutSourceMap(valueMember.node.valueDefinition.typeDefinition));
  }
  }
  };
@@ -660,7 +723,7 @@ namespace drafter {
  using namespace refract;
  typedef T ElementType;
 
- ElementData<T> data;
+ ElementData<ElementType> data;
  ElementType* element = new ElementType;
 
  ExtractValueMember<ElementType>(data, defaultNestedType)(value);
@@ -956,6 +1019,10 @@ namespace drafter {
 
  ElementData<T> data;
 
+ ExtractTypeDefinition<ElementType> extd(data);
+ extd(MAKE_NODE_INFO(ds, typeDefinition));
+ //ExtractTypeDefinition<T>(data)(MAKE_NODE_INFO(ds, typeDefinition));
+
  NodeInfoCollection<mson::TypeSections> typeSections(MAKE_NODE_INFO(ds, sections));
 
  std::for_each(typeSections.begin(), typeSections.end(), ExtractTypeSection<T>(data, ds));