Gives MojomFile a slice in order to store its imports in a specified order.

mojom/mojom_parser/parser/parse_driver.go

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 package parser
 
 import (
         "fmt"
         "io/ioutil"
         "mojom/mojom_parser/mojom"
@@ skipping 86 matching lines @@
                 filesToProcess = filesToProcess[1:]
                 if err = d.fileProvider.findFile(currentFile); err != nil {
                         return
                 }
 
                 if currentFile.importedFrom != nil {
                         // Tell the importing file about the absolute path of the imported file.
                         // Note that we must do this even if the imported file has already been processed
                         // because a given file may be imported by multiple files and each of those need
                         // to be told about the absolute path of the imported file.
-                        currentFile.importedFrom.mojomFile.Imports[currentFile.specifiedPath] = currentFile.absolutePath
+                        currentFile.importedFrom.mojomFile.SetCanonicalImportName(currentFile.specifiedPath, currentFile.absolutePath)
                 }
 
                 if !descriptor.ContainsFile(currentFile.absolutePath) {
                         contents, fileReadError := d.fileProvider.provideContents(currentFile)
                         if fileReadError != nil {
                                 err = fileReadError
                                 return
                         }
                         parser := MakeParser(currentFile.absolutePath, contents, descriptor)
                         parser.SetDebugMode(d.debugMode)
                         // Invoke parser.Parse() (but skip doing so in tests sometimes.)
                         d.parseInvoker.invokeParse(&parser)
 
                         if d.debugMode {
                                 fmt.Printf("\nParseTree for %s:", currentFile)
                                 fmt.Println(parser.GetParseTree())
                         }
 
                         if !parser.OK() {
                                 err = fmt.Errorf("\nError while parsing %s: \n%s\n",
                                         currentFile, parser.GetError().Error())
                                 return
                         }
                         currentFile.mojomFile = d.fileExtractor.extractMojomFile(&parser)
-                        for importedFile, _ := range currentFile.mojomFile.Imports {
+                        for _, importedFile := range currentFile.mojomFile.Imports {
                                 // Note that it is important that we append all of the imported files here even
                                 // if some of them have already been processed. That is because when the imported
                                 // file is pulled from the queue it will be pre-processed during which time the
                                 // absolute path to the file will be discovered and this absolute path will be
                                 // set in |mojomFile| which is necessary for serializing mojomFile.
                                 filesToProcess = append(filesToProcess,
-                                        &FileReference{importedFrom: currentFile, specifiedPath: importedFile})
+                                        &FileReference{importedFrom: currentFile, specifiedPath: importedFile.SpecifiedName})
                         }
                 }
         }
 
         // Perform type and value resolution
         if err = descriptor.Resolve(); err != nil {
                 return
         }
 
         // Compute data for generators.
@@ skipping 119 matching lines @@
         return fmt.Errorf("File not found: %s", fileRef)
 }
 
 func isFile(path string) bool {
         info, err := os.Stat(path)
         if err != nil {
                 return false
         }
         return !info.IsDir()
 }