Remove everything to do with snippets

client/dom/scripts/dartgenerator.py

 #!/usr/bin/python
 # Copyright (c) 2011, the Dart project authors.  Please see the AUTHORS file
 # for details. All rights reserved. Use of this source code is governed by a
 # BSD-style license that can be found in the LICENSE file.
 
 """This module generates Dart APIs from the IDL database."""
 
 import emitter
 import idlnode
 import logging
 import multiemitter
 import os
 import re
 import shutil
-import snippet_manager
 
 _logger = logging.getLogger('dartgenerator')
 
 # IDL->Dart primitive types conversion.
 _idl_to_dart_type_conversions = {
     'any': 'Object',
     'custom': 'Dynamic',
     'boolean': 'bool',
     'DOMObject': 'Object',
     'DOMString': 'String',
@@ skipping 120 matching lines @@
 def _IsDartListType(type):
   return type == 'List' or type.startswith('List<')
 
 def _IsDartCollectionType(type):
   return _IsDartListType(type)
 
 
 class DartGenerator(object):
   """Utilities to generate Dart APIs and corresponding JavaScript."""
 
-  def __init__(self, auxiliary_dir, snippet_dir, base_package):
+  def __init__(self, auxiliary_dir, base_package):
     """Constructor for the DartGenerator.
 
     Args:
       auxiliary_dir -- location of auxiliary handwritten classes
-      snippet_dir -- location of implementation snippets
       base_package -- the base package name for the generated code.
     """
     self._auxiliary_dir = auxiliary_dir
-    self._snippet_manager = snippet_manager.SnippetManager(snippet_dir)
     self._base_package = base_package
     self._auxiliary_files = {}
     self._dart_templates_re = re.compile(r'[\w.:]+<([\w\.<>:]+)>')
 
     self._emitters = None  # set later
 
 
   def _StripModules(self, type_name):
     return type_name.split('::')[-1]
 
@@ skipping 168 matching lines @@
         for a in and_annotations:
           if a not in idl_node.annotations:
             return False
         return True
 
       if HasAnnotations(interface):
         interface.constants = filter(HasAnnotations, interface.constants)
         interface.attributes = filter(HasAnnotations, interface.attributes)
         interface.operations = filter(HasAnnotations, interface.operations)
         interface.parents = filter(HasAnnotations, interface.parents)
-        interface.snippets = filter(HasAnnotations, interface.snippets)
       else:
         database.DeleteInterface(interface.id)
 
     self.FilterMembersWithUnidentifiedTypes(database)
 
 
   def Generate(self, database, output_dir,
                module_source_preference=[], source_filter=None,
                super_database=None, common_prefix=None, super_map={},
                lib_dir = None):
@@ skipping 388 matching lines @@
 
     self._dart_interface_file_paths.append(dart_interface_file_path)
 
     dart_interface_code = self._emitters.FileEmitter(dart_interface_file_path)
 
     template_file = 'template_interface_%s.darttemplate' % interface_name
     if not os.path.exists(template_file):
       template_file = 'template_interface.darttemplate'
     template = ''.join(open(template_file).readlines())
 
-    snippet = self._snippet_manager.snippet_map.get(interface_name)
-
     return DartInterfaceGenerator(
         interface, dart_interface_code,
         template,
-        snippet, common_prefix, super_interface_name,
+        common_prefix, super_interface_name,
         source_filter)
 
 
   def _StartGenerateWrappingImpl(self, output_dir):
     """Prepared for generating wrapping implementation.
 
     - Creates emitter for JS code.
     - Creates emitter for Dart code.
     """
     js_file_name = os.path.join(output_dir, 'wrapping_dom.js')
@@ skipping 288 matching lines @@
     else:
       return '\n'
   return ''.join(FormatLine(line) for line in text.split('\n'))
 
 # ------------------------------------------------------------------------------
 
 class DartInterfaceGenerator(object):
   """Generates Dart Interface definition for one DOM IDL interface."""
 
   def __init__(self, interface, emitter, template,
-               extra_snippets, common_prefix, super_interface, source_filter):
+               common_prefix, super_interface, source_filter):
     """Generates Dart code for the given interface.
 
     Args:
       interface -- an IDLInterface instance. It is assumed that all types have
         been converted to Dart types (e.g. int, String), unless they are in the
         same package as the interface.
-      extra_snippets -- additional snippet text with method signatures that were
-        extracted from the implementation snippet file
       common_prefix -- the prefix for the common library, if any.
       super_interface -- the name of the common interface that this interface
         implements, if any.
       source_filter -- if specified, rewrites the names of any superinterfaces
         that are not from these sources to use the common prefix.
     """
     self._interface = interface
     self._emitter = emitter
     self._template = template
-    self._extra_snippets = extra_snippets
     self._common_prefix = common_prefix
     self._super_interface = super_interface
     self._source_filter = source_filter
 
 
   def StartInterface(self):
     if self._super_interface:
       typename = self._super_interface
     else:
       typename = self._interface.id
@@ skipping 40 matching lines @@
           '  $CTOR(int length);\n'
           '\n'
           '  $CTOR.fromList(List<$TYPE> list);\n'
           '\n'
           '  $CTOR.fromBuffer(ArrayBuffer buffer);\n',
         CTOR=self._interface.id,
         TYPE=element_type)
 
 
   def FinishInterface(self):
-    # Write snippet text that was inlined in the IDL.
-    for snippet in self._interface.snippets:
-      self._members_emitter.Emit('\n$LINES',
-                                 LINES=IndentText(snippets.text, '  '))
-
-    # TODO(vsm): Test if snippets are extra methods or extra types.
-    # Since Dart doesn't permit inner types, append after the interface.
-    # Consider moving these types to auxilary classes instead.
-    if self._extra_snippets is not None:
-      if 'interface' in self._extra_snippets:
-        self._top_level_emitter.Emit('\n$TEXT', TEXT=self._extra_snippets)
-      else:
-        self._members_emitter.Emit('\n$TEXT',
-                                   TEXT=IndentText(self._extra_snippets, '  '))
-
     # TODO(vsm): Use typedef if / when that is supported in Dart.
     # Define variant as subtype.
     if (self._super_interface and
         self._interface.id is not self._super_interface):
       consts_emitter = self._top_level_emitter.Emit(
           '\n'
           'interface $NAME extends $BASE {\n'
           '$!CONSTS'
           '}\n',
           NAME=self._interface.id,
@@ skipping 795 matching lines @@
     Arguments:
       info: An OperationInfo object.
     """
     # TODO(vsm): Handle overloads.
     self._members_emitter.Emit(
         '\n'
         '  $TYPE $NAME($ARGS) native;\n',
         TYPE=info.type_name,
         NAME=info.name,
         ARGS=info.arg_implementation_declaration)