[wasm] [asmjs] Route asm.js warnings to the dev console.

src/asmjs/asm-typer.h

 // Copyright 2016 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef SRC_ASMJS_ASM_TYPER_H_
 #define SRC_ASMJS_ASM_TYPER_H_
 
 #include <cstdint>
 #include <string>
 #include <unordered_map>
 #include <unordered_set>
 
 #include "src/allocation.h"
 #include "src/asmjs/asm-types.h"
 #include "src/ast/ast-type-bounds.h"
 #include "src/ast/ast-types.h"
 #include "src/ast/ast.h"
 #include "src/effects.h"
+#include "src/messages.h"
 #include "src/type-info.h"
 #include "src/zone/zone-containers.h"
 #include "src/zone/zone.h"
 
 namespace v8 {
 namespace internal {
 namespace wasm {
 
 class AsmType;
 class AsmTyperHarnessBuilder;
@@ skipping 42 matching lines @@
   AsmTyper(Isolate* isolate, Zone* zone, Handle<Script> script,
            FunctionLiteral* root);
 
   bool Validate();
   // Do asm.js validation in phases (to interleave with conversion to wasm).
   bool ValidateBeforeFunctionsPhase();
   bool ValidateInnerFunction(FunctionDeclaration* decl);
   bool ValidateAfterFunctionsPhase();
   void ClearFunctionNodeTypes();
 
-  const char* error_message() const { return error_message_; }
+  Handle<JSMessageObject> error_message() const { return error_message_; }
+  const MessageLocation* message_location() const { return &message_location_; }
 
   AsmType* TypeOf(AstNode* node) const;
   AsmType* TypeOf(Variable* v) const;
   StandardMember VariableAsStandardMember(Variable* var);
 
   typedef std::unordered_set<StandardMember, std::hash<int> > StdlibSet;
 
   StdlibSet StdlibUses() const { return stdlib_uses_; }
 
   // Each FFI import has a usage-site signature associated with it.
@@ skipping 39 matching lines @@
     bool IsGlobal() const {
       return mutability_ == kImmutableGlobal || mutability_ == kConstGlobal ||
              mutability_ == kMutableGlobal;
     }
 
     bool IsStdlib() const { return standard_member_ == kStdlib; }
     bool IsFFI() const { return standard_member_ == kFFI; }
     bool IsHeap() const { return standard_member_ == kHeap; }
 
     void MarkDefined() { missing_definition_ = false; }
-    void SetFirstForwardUse(int source_location);
+    void SetFirstForwardUse(const MessageLocation& source_location);
 
     StandardMember standard_member() const { return standard_member_; }
     void set_standard_member(StandardMember standard_member) {
       standard_member_ = standard_member;
     }
 
     AsmType* type() const { return type_; }
     void set_type(AsmType* type) { type_ = type; }
 
     Mutability mutability() const { return mutability_; }
     void set_mutability(Mutability mutability) { mutability_ = mutability; }
 
     bool missing_definition() const { return missing_definition_; }
 
-    int source_location() const { return source_location_; }
+    const MessageLocation* source_location() { return &source_location_; }
 
     static VariableInfo* ForSpecialSymbol(Zone* zone,
                                           StandardMember standard_member);
 
    private:
     AsmType* type_;
     StandardMember standard_member_ = kNone;
     Mutability mutability_ = kInvalidMutability;
     // missing_definition_ is set to true for forward definition - i.e., use
     // before definition.
     bool missing_definition_ = false;
-    // source_location_ holds the line number that first referenced this
-    // VariableInfo. Used for error messages.
-    // TODO(bradnelson): When merged with console change, this should
-    // become a source location.
-    int source_location_ = -1;
+    // Used for error messages.
+    MessageLocation source_location_;
   };
 
   // RAII-style manager for the in_function_ member variable.
   struct FunctionScope {
     explicit FunctionScope(AsmTyper* typer) : typer_(typer) {
       DCHECK(!typer_->in_function_);
       typer_->in_function_ = true;
       typer_->local_scope_.Clear();
       typer_->return_type_ = AsmType::None();
     }
@@ skipping 207 matching lines @@
   ZoneHashMap global_scope_;  // 3.1 Global environment
   ZoneHashMap local_scope_;   // 3.2 Variable environment
 
   std::uintptr_t stack_limit_;
   bool stack_overflow_ = false;
   std::unordered_map<AstNode*, AsmType*> module_node_types_;
   std::unordered_map<AstNode*, AsmType*> function_node_types_;
   static const int kErrorMessageLimit = 128;
   AsmType* fround_type_;
   AsmType* ffi_type_;
-  char error_message_[kErrorMessageLimit];
+  Handle<JSMessageObject> error_message_;
+  MessageLocation message_location_;
   StdlibSet stdlib_uses_;
 
   SourceLayoutTracker source_layout_;
   ReturnStatement* module_return_;
   ZoneVector<Assignment*> function_pointer_tables_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(AsmTyper);
 };
 
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8
 
 #endif  // SRC_ASMJS_ASM_TYPER_H_