Only have one coredata object because two is just wasteful.

backends.py

@@ -126,13 +126,13 @@ class Backend():
         commands = []
         commands += self.build.get_global_flags(compiler)
         commands += target.get_extra_args(compiler.get_language())
-        if self.environment.new_coredata.buildtype != 'plain':
+        if self.environment.coredata.buildtype != 'plain':
             commands += compiler.get_debug_flags()
-        if self.environment.new_coredata.buildtype == 'optimized':
+            commands += compiler.get_std_warn_flags()
+        if self.environment.coredata.buildtype == 'optimized':
             commands += compiler.get_std_opt_flags()
-        if self.environment.new_coredata.coverage:
+        if self.environment.coredata.coverage:
             commands += compiler.get_coverage_flags()
-        commands += compiler.get_std_warn_flags()
         if isinstance(target, interpreter.SharedLibrary):
             commands += compiler.get_pic_flags()
         for dep in target.get_external_deps():
@@ -243,7 +243,7 @@ class NinjaBackend(Backend):
         self.generate_tests(outfile)
         outfile.write('# Install rules\n\n')
         self.generate_install(outfile)
-        if self.environment.new_coredata.coverage:
+        if self.environment.coredata.coverage:
             outfile.write('# Coverage rules\n\n')
             self.generate_coverage_rules(outfile)
         outfile.write('# Suffix\n\n')
@@ -301,7 +301,7 @@ class NinjaBackend(Backend):
         libdir = self.environment.get_libdir()
         bindir = self.environment.get_bindir()
 
-        should_strip = self.environment.new_coredata.strip
+        should_strip = self.environment.coredata.strip
         for t in self.build.get_targets().values():
             if t.should_install():
                 if isinstance(t, interpreter.Executable):
@@ -521,7 +521,7 @@ class NinjaBackend(Backend):
             commands += dep.get_link_flags()
         dependencies = target.get_dependencies()
         commands += self.build_target_link_arguments(dependencies)
-        if self.environment.new_coredata.coverage:
+        if self.environment.coredata.coverage:
             commands += linker.get_coverage_link_flags()
         dep_targets = [self.get_target_filename(t) for t in dependencies]
         elem = NinjaBuildElement(outname, linker_rule, obj_list)

environment.py

@@ -241,10 +241,9 @@ class Environment():
 
         try:
             cdf = os.path.join(self.get_build_dir(), Environment.coredata_file)
-            self.old_coredata = coredata.load(cdf)
+            self.coredata = coredata.load(cdf)
         except IOError:
-            self.old_coredata = coredata.CoreData(options)
-        self.new_coredata = coredata.CoreData(self.old_coredata)
+            self.coredata = coredata.CoreData(options)
 
         self.default_c = ['cc']
         self.default_cxx = ['c++']
@@ -259,16 +258,13 @@ class Environment():
 
     def generating_finished(self):
         cdf = os.path.join(self.get_build_dir(), Environment.coredata_file)
-        coredata.save(self.new_coredata, cdf)
+        coredata.save(self.coredata, cdf)
 
     def get_script_dir(self):
         return os.path.dirname(self.meson_script_file)
 
-    def get_old_coredata(self):
-        return self.old_coredata
-
-    def get_new_coredata(self):
-        return self.new_coredata
+    def get_coredata(self):
+        return self.coredata
 
     def get_build_command(self):
         return self.meson_script_file
@@ -376,22 +372,22 @@ class Environment():
         return self.object_suffix
 
     def get_prefix(self):
-        return self.new_coredata.prefix
+        return self.coredata.prefix
 
     def get_libdir(self):
-        return self.new_coredata.libdir
+        return self.coredata.libdir
 
     def get_bindir(self):
-        return self.new_coredata.bindir
+        return self.coredata.bindir
 
     def get_includedir(self):
-        return self.new_coredata.includedir
+        return self.coredata.includedir
 
     def get_mandir(self):
-        return self.new_coredata.mandir
+        return self.coredata.mandir
 
     def get_datadir(self):
-        return self.new_coredata.datadir
+        return self.coredata.datadir
 
 class Dependency():
     def __init__(self):

interpreter.py

@@ -456,8 +456,7 @@ class Interpreter():
         self.build_def_files = [environment.build_filename]
         self.subdir = ''
         self.generators = []
-        self.old_coredata = self.environment.get_old_coredata()
-        self.new_coredata = self.environment.get_new_coredata()
+        self.coredata = self.environment.get_coredata()
 
     def build_func_dict(self):
         self.funcs = {'project' : self.func_project, 
@@ -575,7 +574,7 @@ class Interpreter():
 
     def add_languages(self, node, args):
         for lang in args:
-            if lang in self.new_coredata.compilers:
+            if lang in self.coredata.compilers:
                 comp = self.new_coredata.compilers[lang]
             else:
                 if lang.lower() == 'c':
@@ -585,20 +584,19 @@ class Interpreter():
                 else:
                     raise InvalidCode('Tried to use unknown language "%s".' % lang)
                 comp.sanity_check(self.environment.get_scratch_dir())
-                self.new_coredata.compilers[lang] = comp
+                self.coredata.compilers[lang] = comp
             self.build.compilers.append(comp)
 
     def func_find_dep(self, node, args, kwargs):
         self.validate_arguments(args, 1, [str])
         name = args[0]
-        if name in self.old_coredata.deps:
-            dep = self.old_coredata.deps[name]
-            if not dep.found():
-                raise RuntimeError('Non-found dependency stored in coredata.')
+        if name in self.coredata.deps:
+            dep = self.coredata.deps[name]
         else:
+            dep = environment.Dependency() # Returns always false for dep.found()
+        if not dep.found():
             dep = environment.find_external_dependency(name, kwargs)
-        if dep.found():
-            self.new_coredata.deps[name] = dep
+        self.coredata.deps[name] = dep
         return dep
 
     def func_executable(self, node, args, kwargs):