Changes in src/SymTab/FixFunction.cc [954ef5b:c3acf0aa]

File:

• src/SymTab/FixFunction.cc (modified) (1 diff)

src/SymTab/FixFunction.cc

@@ -26 +26 @@
         FixFunction::FixFunction() : isVoid( false ) {}
 
-
-        DeclarationWithType * FixFunction::postmutate(FunctionDecl *functionDecl) {
-                // can't delete function type because it may contain assertions, so transfer ownership to new object
-                ObjectDecl *pointer = new ObjectDecl( functionDecl->name, functionDecl->get_storageClasses(), functionDecl->linkage, nullptr, new PointerType( Type::Qualifiers(), functionDecl->type ), nullptr, functionDecl->attributes );
-                functionDecl->attributes.clear();
-                functionDecl->type = nullptr;
+        DeclarationWithType * FixFunction::mutate(FunctionDecl *functionDecl) {
+                ObjectDecl *pointer = new ObjectDecl( functionDecl->get_name(), functionDecl->get_storageClasses(), functionDecl->get_linkage(), 0, new PointerType( Type::Qualifiers(), functionDecl->get_type() ), 0, functionDecl->get_attributes() );
+                functionDecl->get_attributes().clear();
+                // can't delete function type because it may contain assertions, but can't transfer ownership without a clone since set_type checks for nullptr
+                functionDecl->set_type( functionDecl->get_type()->clone() );
                 delete functionDecl;
                 return pointer;
         }
 
-        Type * FixFunction::postmutate(ArrayType *arrayType) {
+        Type * FixFunction::mutate(VoidType *voidType) {
+                isVoid = true;
+                return voidType;
+        }
+
+        Type * FixFunction::mutate(BasicType *basicType) {
+                return basicType;
+        }
+
+        Type * FixFunction::mutate(PointerType *pointerType) {
+                return pointerType;
+        }
+
+        Type * FixFunction::mutate(ArrayType *arrayType) {
                 // need to recursively mutate the base type in order for multi-dimensional arrays to work.
-                PointerType *pointerType = new PointerType( arrayType->get_qualifiers(), arrayType->base, arrayType->dimension, arrayType->isVarLen, arrayType->isStatic );
-                arrayType->base = nullptr;
-                arrayType->dimension = nullptr;
+                PointerType *pointerType = new PointerType( arrayType->get_qualifiers(), arrayType->get_base()->clone()->acceptMutator( *this ), maybeClone( arrayType->get_dimension() ), arrayType->get_isVarLen(), arrayType->get_isStatic() );
                 delete arrayType;
                 return pointerType;
         }
 
-        void FixFunction::premutate(VoidType *) {
-                isVoid = true;
+        Type * FixFunction::mutate(StructInstType *aggregateUseType) {
+                return aggregateUseType;
         }
 
-        void FixFunction::premutate(FunctionDecl *) { visit_children = false; }
-        void FixFunction::premutate(ArrayType *) { visit_children = false; }
-        void FixFunction::premutate(BasicType *) { visit_children = false; }
-        void FixFunction::premutate(PointerType *) { visit_children = false; }
-        void FixFunction::premutate(StructInstType *) { visit_children = false; }
-        void FixFunction::premutate(UnionInstType *) { visit_children = false; }
-        void FixFunction::premutate(EnumInstType *) { visit_children = false; }
-        void FixFunction::premutate(TraitInstType *) { visit_children = false; }
-        void FixFunction::premutate(TypeInstType *) { visit_children = false; }
-        void FixFunction::premutate(TupleType *) { visit_children = false; }
-        void FixFunction::premutate(VarArgsType *) { visit_children = false; }
-        void FixFunction::premutate(ZeroType *) { visit_children = false; }
-        void FixFunction::premutate(OneType *) { visit_children = false; }
+        Type * FixFunction::mutate(UnionInstType *aggregateUseType) {
+                return aggregateUseType;
+        }
+
+        Type * FixFunction::mutate(EnumInstType *aggregateUseType) {
+                return aggregateUseType;
+        }
+
+        Type * FixFunction::mutate(TraitInstType *aggregateUseType) {
+                return aggregateUseType;
+        }
+
+        Type * FixFunction::mutate(TypeInstType *aggregateUseType) {
+                return aggregateUseType;
+        }
+
+        Type * FixFunction::mutate(TupleType *tupleType) {
+                return tupleType;
+        }
+
+        Type * FixFunction::mutate(VarArgsType *varArgsType) {
+                return varArgsType;
+        }
+
+        Type * FixFunction::mutate(ZeroType *zeroType) {
+                return zeroType;
+        }
+
+        Type * FixFunction::mutate(OneType *oneType) {
+                return oneType;
+        }
 } // namespace SymTab