Reintroduce duplicate identifier detection in preparser.

test/preparser/testcfg.py

 # Copyright 2011 the V8 project authors. All rights reserved.
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions are
 # met:
 #
 #     * Redistributions of source code must retain the above copyright
 #       notice, this list of conditions and the following disclaimer.
 #     * Redistributions in binary form must reproduce the above
 #       copyright notice, this list of conditions and the following
 #       disclaimer in the documentation and/or other materials provided
@@ skipping 80 matching lines @@
           if (rule_match.group(2)):
             expects = expects + [rule_match.group(2)]
             if (rule_match.group(3)):
               expects = expects + [rule_match.group(3), rule_match.group(4)]
           map[rule_match.group(1)] = expects
     return map;
 
   def ParsePythonTestTemplates(self, result, filename,
                                executable, current_path, mode):
     pathname = join(self.root, filename + ".pyt")
-    source = open(pathname).read();
     def Test(name, source, expectation):
       throws = None
       if (expectation is not None):
         throws = [expectation]
       test = PreparserTestCase(self.root,
                                current_path + [filename, name],
                                executable,
                                mode, throws, self.context,
                                source.replace("\n", " "))
       result.append(test)
     def Template(name, source):
       def MkTest(replacement, expectation):
         testname = name
         testsource = source
         for key in replacement.keys():
           testname = testname.replace("$"+key, replacement[key]);
           testsource = testsource.replace("$"+key, replacement[key]);
         Test(testname, testsource, expectation)
       return MkTest
-    eval(compile(source, pathname, "exec"),
-         {"Test": Test, "Template": Template}, {})
+    execfile(pathname, {"Test": Test, "Template": Template})
 
   def ListTests(self, current_path, path, mode, variant_flags):
     executable = 'preparser'
     if utils.IsWindows():
       executable += '.exe'
     executable = join(self.context.buildspace, executable)
     if not isfile(executable):
       executable = join('obj', 'preparser', mode, 'preparser')
       if utils.IsWindows():
         executable += '.exe'
       executable = join(self.context.buildspace, executable)
     expectations = self.GetExpectations()
     result = []
     # Find all .js files in tests/preparser directory.
     filenames = [f[:-3] for f in os.listdir(self.root) if f.endswith(".js")]
     filenames.sort()
     for file in filenames:
       throws = None;
       if (file in expectations):
         throws = expectations[file]
       result.append(PreparserTestCase(self.root,
                                       current_path + [file], executable,
                                       mode, throws, self.context, None))
     # Find all .pyt files in test/preparser directory.
     filenames = [f[:-4] for f in os.listdir(self.root) if f.endswith(".pyt")]
     filenames.sort()
     for file in filenames:
       # Each file as a python source file to be executed in a specially
-      # perparsed environment (defining the Template and Test functions)
+      # created environment (defining the Template and Test functions)
       self.ParsePythonTestTemplates(result, file,
                                     executable, current_path, mode)
     return result
 
   def GetTestStatus(self, sections, defs):
     status_file = join(self.root, 'preparser.status')
     if exists(status_file):
       test.ReadConfigurationInto(status_file, sections, defs)
 
   def VariantFlags(self):
     return [[]];
 
 
 def GetConfiguration(context, root):
   return PreparserTestConfiguration(context, root)