Complete: Fix global symbol type binding

- Move ValidationError enum outside impl block to fix compilation error
- Fix symbol_id type casting (i -> i as u32) for ValidationError fields
- Restore proper control flow structure in resolve_identifier_symbol
  (add missing if/while scope walking loop that was lost in merge)
- Add Promise<T> interface to lib.d.ts with full method signatures
- Add PromiseConstructor interface with all static methods
- Add Awaited<T> type alias for async/await support
- Add declare var Promise: PromiseConstructor

Co-Authored-By: Claude Opus 4.5 <[email protected]>

Author: mohsen1

tests/lib/lib.d.ts

@@ -1208,6 +1208,105 @@ interface PromiseLike<T> {
     then<TResult>(onfulfilled?: (value: T) => TResult | PromiseLike<TResult>, onrejected?: (reason: any) => void): PromiseLike<TResult>;
 }
 
+/**
+ * Represents the completion of an asynchronous operation
+ */
+interface Promise<T> {
+    /**
+     * Attaches callbacks for the resolution and/or rejection of the Promise.
+     * @param onfulfilled The callback to execute when the Promise is resolved.
+     * @param onrejected The callback to execute when the Promise is rejected.
+     * @returns A Promise for the completion of which ever callback is executed.
+     */
+    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): Promise<TResult1 | TResult2>;
+
+    /**
+     * Attaches a callback for only the rejection of the Promise.
+     * @param onrejected The callback to execute when the Promise is rejected.
+     * @returns A Promise for the completion of the callback.
+     */
+    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): Promise<T | TResult>;
+
+    /**
+     * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected).
+     * The resolved value cannot be modified from the callback.
+     * @param onfinally The callback to execute when the Promise is settled.
+     * @returns A Promise for the completion of the callback.
+     */
+    finally(onfinally?: (() => void) | undefined | null): Promise<T>;
+}
+
+interface PromiseConstructor {
+    /**
+     * A reference to the prototype.
+     */
+    readonly prototype: Promise<any>;
+
+    /**
+     * Creates a new Promise.
+     * @param executor A callback used to initialize the promise. This callback is passed two arguments:
+     * a resolve callback used to resolve the promise with a value or the result of another promise,
+     * and a reject callback used to reject the promise with a provided reason or error.
+     */
+    new <T>(executor: (resolve: (value: T | PromiseLike<T>) => void, reject: (reason?: any) => void) => void): Promise<T>;
+
+    /**
+     * Creates a Promise that is resolved with an array of results when all of the provided Promises
+     * resolve, or rejected when any Promise is rejected.
+     * @param values An array of Promises.
+     * @returns A new Promise.
+     */
+    all<T extends readonly unknown[] | []>(values: T): Promise<{ -readonly [P in keyof T]: Awaited<T[P]> }>;
+
+    /**
+     * Creates a Promise that is resolved or rejected when any of the provided Promises are resolved
+     * or rejected.
+     * @param values An array of Promises.
+     * @returns A new Promise.
+     */
+    race<T extends readonly unknown[] | []>(values: T): Promise<Awaited<T[number]>>;
+
+    /**
+     * Creates a new rejected promise for the provided reason.
+     * @param reason The reason the promise was rejected.
+     * @returns A new rejected Promise.
+     */
+    reject<T = never>(reason?: any): Promise<T>;
+
+    /**
+     * Creates a new resolved promise.
+     * @returns A resolved promise.
+     */
+    resolve(): Promise<void>;
+
+    /**
+     * Creates a new resolved promise for the provided value.
+     * @param value A promise.
+     * @returns A promise whose internal state matches the provided promise.
+     */
+    resolve<T>(value: T): Promise<Awaited<T>>;
+
+    /**
+     * Creates a new resolved promise for the provided value.
+     * @param value A promise.
+     * @returns A promise whose internal state matches the provided promise.
+     */
+    resolve<T>(value: T | PromiseLike<T>): Promise<Awaited<T>>;
+}
+
+declare var Promise: PromiseConstructor;
+
+/**
+ * Recursively unwraps the "awaited type" of a type. Non-promise "thenables" should resolve to `never`. This emulates the behavior of `await`.
+ */
+type Awaited<T> =
+    T extends null | undefined ? T :
+    T extends object & { then(onfulfilled: infer F, ...args: infer _): any } ?
+        F extends ((value: infer V, ...args: infer _) => any) ?
+            Awaited<V> :
+            never :
+    T;
+
 interface ArrayLike<T> {
     length: number;
     [n: number]: T;

wasm/src/thin_binder.rs

@@ -77,6 +77,17 @@ pub struct ThinBinderState {
     current_scope_id: ScopeId,
 }
 
+/// Validation result describing issues found in the symbol table
+#[derive(Debug, Clone, PartialEq)]
+pub enum ValidationError {
+    /// A node->symbol mapping points to a non-existent symbol
+    BrokenSymbolLink { node_index: u32, symbol_id: u32 },
+    /// A symbol exists but has no declarations (orphaned)
+    OrphanedSymbol { symbol_id: u32, name: String },
+    /// A symbol's value_declaration points to a non-existent node
+    InvalidValueDeclaration { symbol_id: u32, name: String },
+}
+
 impl ThinBinderState {
     pub fn new() -> Self {
         let mut flow_nodes = FlowNodeArena::new();
@@ -3583,17 +3594,6 @@ impl ThinBinderState {
         self.bind_node(arena, idx);
     }
 
-    /// Validation result describing issues found in the symbol table
-    #[derive(Debug, Clone, PartialEq)]
-    pub enum ValidationError {
-        /// A node->symbol mapping points to a non-existent symbol
-        BrokenSymbolLink { node_index: u32, symbol_id: u32 },
-        /// A symbol exists but has no declarations (orphaned)
-        OrphanedSymbol { symbol_id: u32, name: String },
-        /// A symbol's value_declaration points to a non-existent node
-        InvalidValueDeclaration { symbol_id: u32, name: String },
-    }
-
     /// Run post-binding validation checks on the symbol table.
     /// Returns a list of validation errors found.
     pub fn validate_symbol_table(&self) -> Vec<ValidationError> {
@@ -3613,7 +3613,7 @@ impl ThinBinderState {
             if let Some(sym) = self.symbols.get(sym_id) {
                 if sym.declarations.is_empty() {
                     errors.push(ValidationError::OrphanedSymbol {
-                        symbol_id: i,
+                        symbol_id: i as u32,
                         name: sym.escaped_name.clone(),
                     });
                 }
@@ -3627,7 +3627,7 @@ impl ThinBinderState {
                     let has_node_mapping = self.node_symbols.contains_key(&sym.value_declaration.0);
                     if !has_node_mapping {
                         errors.push(ValidationError::InvalidValueDeclaration {
-                            symbol_id: i,
+                            symbol_id: i as u32,
                             name: sym.escaped_name.clone(),
                         });
                     }

wasm/src/thin_checker.rs

@@ -297,7 +297,6 @@ impl<'a> ThinCheckerState<'a> {
         let node = self.ctx.arena.get(idx)?;
         let name = self.ctx.arena.get_identifier(node)?.escaped_text.as_str();
 
-
         // Collect lib binders for cross-arena symbol lookup
         let lib_binders: Vec<Arc<crate::thin_binder::ThinBinderState>> =
             self.ctx.lib_contexts.iter().map(|lc| Arc::clone(&lc.binder)).collect();
@@ -309,6 +308,18 @@ impl<'a> ThinCheckerState<'a> {
                 name, idx
             );
         }
+
+        if let Some(mut scope_id) = self.find_enclosing_scope(idx) {
+            let require_export = false;
+            while !scope_id.is_none() {
+                if let Some(scope) = self.ctx.binder.scopes.get(scope_id.0 as usize) {
+                    if let Some(sym_id) = scope.table.get(name) {
+                        if let Some(symbol) = self.ctx.binder.get_symbol_with_libs(sym_id, &lib_binders) {
+                            let export_ok = !require_export
+                                || scope.kind != ContainerKind::Module
+                                || symbol.is_exported
+                                || (symbol.flags & symbol_flags::EXPORT_VALUE) != 0;
+                            if export_ok && !Self::is_class_member_symbol(symbol.flags) {
                                 if std::env::var("BIND_DEBUG").is_ok() {
                                     eprintln!("[BIND_RESOLVE] Found '{}' in scope {:?}", name, scope_id);
                                 }