Now can compile Vala executables.

backends.py

@@ -179,15 +179,25 @@ class Backend():
         self.write_test_file(datafile)
         datafile.close()
 
+    def has_vala(self, target):
+        for s in target.get_sources():
+            if s.endswith('.vala'):
+                return True
+        return False
+
     def generate_target(self, target, outfile):
         name = target.get_basename()
+        gen_src_deps = []
         if name in self.processed_targets:
             return
         if isinstance(target, build.Jar):
             self.generate_jar_target(target, outfile)
             return
+        if 'vala' in self.environment.coredata.compilers.keys() and self.has_vala(target):
+            gen_src_deps += self.generate_vala_compile(target, outfile)
         # The following deals with C/C++ compilation.
-        (gen_src_deps, gen_other_deps) = self.process_dep_gens(outfile, target)
+        (gen_src, gen_other_deps) = self.process_dep_gens(outfile, target)
+        gen_src_deps += gen_src
         self.process_target_dependencies(target, outfile)
         self.generate_custom_generator_rules(target, outfile)
         outname = self.get_target_filename(target)
@@ -228,6 +238,8 @@ class Backend():
                     # move them from orderdeps to proper deps.
                     obj_list.append(self.generate_single_compile(target, outfile, src, True, [], header_deps))
         for src in target.get_sources():
+            if src.endswith('.vala'):
+                continue
             if not self.environment.is_header(src):
                 src_list.append(src)
                 if is_unity:
@@ -264,7 +276,10 @@ class Backend():
             for s in src:
                 if c.can_compile(s):
                     return cpp
-        return self.build.compilers[0]
+        for c in self.build.compilers:
+            if c.get_language() != 'vala':
+                return c
+        raise RuntimeError('Unreachable code')
 
     def determine_ext_objs(self, extobj, proj_dir_to_build_root=''):
         result = []

environment.py

@@ -574,6 +574,9 @@ class ValaCompiler():
         if pc.returncode != 0:
             raise EnvironmentException('Vala compiler %s can not compile programs.' % self.name_string())
 
+    def can_compile(self, fname):
+        return fname.endswith('.vala')
+
 class VisualStudioCCompiler(CCompiler):
     std_warn_flags = ['/W3']
     std_opt_flags= ['/O2']

interpreter.py

@@ -894,9 +894,6 @@ class Interpreter():
         if 'vala' in langs:
             if not 'c' in langs:
                 raise InterpreterException('Compiling Vala requires a C compiler')
-            # These are the implicit dependencies of Vala.
-            self.func_dependency(None, ['glib-2.0'], {})
-            self.func_dependency(None, ['gobject-2.0'], {})
 
     def func_message(self, node, args, kwargs):
         self.validate_arguments(args, 1, [str])

ninjabackend.py

@@ -419,6 +419,24 @@ class NinjaBackend(backends.Backend):
         outfile.write(description)
         outfile.write('\n')
 
+    def generate_vala_compile(self, target, outfile):
+        """Vala is compiled into C. Set up all necessary build steps here."""
+        valac = self.environment.coredata.compilers['vala']
+        generated_c = []
+        for s in target.get_sources():
+            if not s.endswith('.vala'):
+                continue
+            flags = ['-d', self.get_target_private_dir(target)]
+            sc = os.path.basename(s)[:-4] + 'c'
+            flags += ['-C', '-o', sc]
+            relsc = os.path.join(self.get_target_dir(target), target.get_basename() + '.dir', sc)
+            rel_s = os.path.join(self.build_to_src, s)
+            generated_c += [relsc]
+            element = NinjaBuildElement(relsc, valac.get_language() + '_COMPILER', rel_s)
+            element.add_item('FLAGS', flags)
+            element.write(outfile)
+        return generated_c
+
     def generate_static_link_rules(self, is_cross, outfile):
         if self.build.has_language('java'):
             if not is_cross:
@@ -445,7 +463,7 @@ class NinjaBackend(backends.Backend):
         for (complist, is_cross) in ctypes:
             for compiler in complist:
                 langname = compiler.get_language()
-                if langname == 'java':
+                if langname == 'java' or langname == 'vala':
                     continue
                 crstr = ''
                 if is_cross:
@@ -502,6 +520,7 @@ class NinjaBackend(backends.Backend):
         if langname == 'vala':
             if not is_cross:
                 self.generate_vala_compile_rules(compiler, outfile)
+            return
         if is_cross:
             crstr = '_CROSS'
         else:

test cases/vala/1 basic/meson.build

@@ -1,4 +1,6 @@
 project('valatest', 'vala', 'c')
 
-e = executable('valaprog', 'prog.vala')
+valadeps = [dependency('glib-2.0'), dependency('gobject-2.0')]
+
+e = executable('valaprog', 'prog.vala', deps : valadeps)
 test('valatest', e)

test cases/vala/1 basic/prog.vala

@@ -1,7 +1,7 @@
 class MainProg : GLib.Object {
 
-    public static int main(strings[] args) {
-        stdout.printf("Vala is working.");
+    public static int main(string[] args) {
+        stdout.printf("Vala is working.\n");
         return 0;
     }
 }