// Copyright (c) 2012, 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.

library dart2js.js.enqueue;

import 'dart:collection' show Queue;

import '../cache_strategy.dart' show CacheStrategy;
import '../common/backend_api.dart' show Backend;
import '../common/codegen.dart' show CodegenWorkItem;
import '../common/tasks.dart' show CompilerTask;
import '../common/work.dart' show WorkItem;
import '../common.dart';
import '../compiler.dart' show Compiler;
import '../dart_types.dart' show DartType, InterfaceType;
import '../elements/elements.dart' show Entity, MemberElement, TypedElement;
import '../elements/entities.dart';
import '../enqueue.dart';
import '../native/native.dart' as native;
import '../options.dart';
import '../types/types.dart' show TypeMaskStrategy;
import '../universe/world_builder.dart';
import '../universe/use.dart'
    show DynamicUse, StaticUse, StaticUseKind, TypeUse, TypeUseKind;
import '../universe/world_impact.dart'
    show ImpactUseCase, WorldImpact, WorldImpactVisitor;
import '../util/enumset.dart';
import '../util/util.dart' show Setlet;

/// [Enqueuer] which is specific to code generation.
class CodegenEnqueuer extends EnqueuerImpl {
  final String name;
  final EnqueuerStrategy strategy;

  Set<ClassEntity> _recentClasses = new Setlet<ClassEntity>();
  final CodegenWorldBuilderImpl _universe;
  final WorkItemBuilder _workItemBuilder;

  bool queueIsClosed = false;
  final CompilerTask task;
  final native.NativeEnqueuer nativeEnqueuer;
  final Backend _backend;
  final CompilerOptions _options;

  WorldImpactVisitor _impactVisitor;

  final Queue<WorkItem> _queue = new Queue<WorkItem>();

  /// All declaration elements that have been processed by codegen.
  final Set<Entity> _processedEntities = new Set<Entity>();

  final Set<Entity> newlyEnqueuedElements;

  final Set<DynamicUse> newlySeenSelectors;

  static const ImpactUseCase IMPACT_USE =
      const ImpactUseCase('CodegenEnqueuer');

  CodegenEnqueuer(this.task, CacheStrategy cacheStrategy, Backend backend,
      CompilerOptions options, this.strategy)
      : _universe =
            new CodegenWorldBuilderImpl(backend, const TypeMaskStrategy()),
        _workItemBuilder = new CodegenWorkItemBuilder(backend, options),
        newlyEnqueuedElements = cacheStrategy.newSet(),
        newlySeenSelectors = cacheStrategy.newSet(),
        nativeEnqueuer = backend.nativeCodegenEnqueuer(),
        this._backend = backend,
        this._options = options,
        this.name = 'codegen enqueuer' {
    _impactVisitor = new EnqueuerImplImpactVisitor(this);
  }

  CodegenWorldBuilder get universe => _universe;

  bool get queueIsEmpty => _queue.isEmpty;

  /// Returns [:true:] if this enqueuer is the resolution enqueuer.
  bool get isResolutionQueue => false;

  /// Create a [WorkItem] for [entity] and add it to the work list if it has not
  /// already been processed.
  void _addToWorkList(MemberEntity entity) {
    if (_processedEntities.contains(entity)) return;

    WorkItem workItem = _workItemBuilder.createWorkItem(entity);
    if (workItem == null) return;

    if (_options.hasIncrementalSupport) {
      newlyEnqueuedElements.add(entity);
    }

    if (queueIsClosed) {
      throw new SpannableAssertionFailure(
          entity, "Codegen work list is closed. Trying to add $entity");
    }

    applyImpact(_backend.registerUsedElement(entity, forResolution: false));
    _queue.add(workItem);
  }

  void applyImpact(WorldImpact worldImpact, {var impactSource}) {
    if (worldImpact.isEmpty) return;
    impactStrategy.visitImpact(
        impactSource, worldImpact, _impactVisitor, impactUse);
  }

  void _registerInstantiatedType(InterfaceType type,
      {bool mirrorUsage: false, bool nativeUsage: false}) {
    task.measure(() {
      _universe.registerTypeInstantiation(type, _applyClassUse,
          byMirrors: mirrorUsage);
      if (nativeUsage) {
        nativeEnqueuer.onInstantiatedType(type);
      }
      _backend.registerInstantiatedType(type);
    });
  }

  bool checkNoEnqueuedInvokedInstanceMethods() {
    return strategy.checkEnqueuerConsistency(this);
  }

  void checkClass(ClassEntity cls) {
    _universe.processClassMembers(cls, (MemberEntity member, useSet) {
      if (useSet.isNotEmpty) {
        _backend.compiler.reporter.internalError(member,
            'Unenqueued use of $member: ${useSet.iterable(MemberUse.values)}');
      }
    });
  }

  /// Callback for applying the use of a [cls].
  void _applyClassUse(ClassEntity cls, EnumSet<ClassUse> useSet) {
    if (useSet.contains(ClassUse.INSTANTIATED)) {
      _recentClasses.add(cls);
      _universe.processClassMembers(cls, _applyMemberUse);
      // We only tell the backend once that [cls] was instantiated, so
      // any additional dependencies must be treated as global
      // dependencies.
      applyImpact(
          _backend.registerInstantiatedClass(cls, forResolution: false));
    }
    if (useSet.contains(ClassUse.IMPLEMENTED)) {
      applyImpact(_backend.registerImplementedClass(cls, forResolution: false));
    }
  }

  /// Callback for applying the use of a [member].
  void _applyMemberUse(Entity member, EnumSet<MemberUse> useSet) {
    if (useSet.contains(MemberUse.NORMAL)) {
      _addToWorkList(member);
    }
    if (useSet.contains(MemberUse.CLOSURIZE_INSTANCE)) {
      _registerClosurizedMember(member);
    }
    if (useSet.contains(MemberUse.CLOSURIZE_STATIC)) {
      applyImpact(_backend.registerGetOfStaticFunction());
    }
  }

  void processDynamicUse(DynamicUse dynamicUse) {
    task.measure(() {
      if (_universe.registerDynamicUse(dynamicUse, _applyMemberUse)) {
        if (_options.hasIncrementalSupport) {
          newlySeenSelectors.add(dynamicUse);
        }
      }
    });
  }

  void processStaticUse(StaticUse staticUse) {
    _universe.registerStaticUse(staticUse, _applyMemberUse);
    switch (staticUse.kind) {
      case StaticUseKind.CONSTRUCTOR_INVOKE:
      case StaticUseKind.CONST_CONSTRUCTOR_INVOKE:
      case StaticUseKind.REDIRECTION:
        processTypeUse(new TypeUse.instantiation(staticUse.type));
        break;
      default:
        break;
    }
  }

  void processTypeUse(TypeUse typeUse) {
    DartType type = typeUse.type;
    switch (typeUse.kind) {
      case TypeUseKind.INSTANTIATION:
        _registerInstantiatedType(type);
        break;
      case TypeUseKind.MIRROR_INSTANTIATION:
        _registerInstantiatedType(type, mirrorUsage: true);
        break;
      case TypeUseKind.NATIVE_INSTANTIATION:
        _registerInstantiatedType(type, nativeUsage: true);
        break;
      case TypeUseKind.IS_CHECK:
      case TypeUseKind.AS_CAST:
      case TypeUseKind.CATCH_TYPE:
        _registerIsCheck(type);
        break;
      case TypeUseKind.CHECKED_MODE_CHECK:
        if (_options.enableTypeAssertions) {
          _registerIsCheck(type);
        }
        break;
      case TypeUseKind.TYPE_LITERAL:
        break;
    }
  }

  void _registerIsCheck(DartType type) {
    type = _universe.registerIsCheck(type);
    // Even in checked mode, type annotations for return type and argument
    // types do not imply type checks, so there should never be a check
    // against the type variable of a typedef.
    assert(!type.isTypeVariable || !type.element.enclosingElement.isTypedef);
  }

  void _registerClosurizedMember(TypedElement element) {
    assert(element.isInstanceMember);
    if (element.type.containsTypeVariables) {
      applyImpact(_backend.registerClosureWithFreeTypeVariables(element,
          forResolution: false));
    }
    applyImpact(_backend.registerBoundClosure());
  }

  void forEach(void f(WorkItem work)) {
    do {
      while (_queue.isNotEmpty) {
        // TODO(johnniwinther): Find an optimal process order.
        WorkItem work = _queue.removeLast();
        if (!_processedEntities.contains(work.element)) {
          strategy.processWorkItem(f, work);
          // TODO(johnniwinther): Register the processed element here. This
          // is currently a side-effect of calling `work.run`.
          _processedEntities.add(work.element);
        }
      }
      List recents = _recentClasses.toList(growable: false);
      _recentClasses.clear();
      if (!_onQueueEmpty(recents)) _recentClasses.addAll(recents);
    } while (_queue.isNotEmpty || _recentClasses.isNotEmpty);
  }

  /// [_onQueueEmpty] is called whenever the queue is drained. [recentClasses]
  /// contains the set of all classes seen for the first time since
  /// [_onQueueEmpty] was called last. A return value of [true] indicates that
  /// the [recentClasses] have been processed and may be cleared. If [false] is
  /// returned, [_onQueueEmpty] will be called once the queue is empty again (or
  /// still empty) and [recentClasses] will be a superset of the current value.
  bool _onQueueEmpty(Iterable<ClassEntity> recentClasses) {
    return _backend.onQueueEmpty(this, recentClasses);
  }

  void logSummary(log(message)) {
    log('Compiled ${_processedEntities.length} methods.');
    nativeEnqueuer.logSummary(log);
  }

  String toString() => 'Enqueuer($name)';

  ImpactUseCase get impactUse => IMPACT_USE;

  void forgetEntity(Entity entity, Compiler compiler) {
    _universe.forgetElement(entity, compiler);
    _processedEntities.remove(entity);
  }

  @override
  Iterable<Entity> get processedEntities => _processedEntities;

  @override
  Iterable<ClassEntity> get processedClasses => _universe.processedClasses;
}

/// Builder that creates the work item necessary for the code generation of a
/// [MemberElement].
class CodegenWorkItemBuilder extends WorkItemBuilder {
  Backend _backend;
  CompilerOptions _options;

  CodegenWorkItemBuilder(this._backend, this._options);

  @override
  WorkItem createWorkItem(MemberElement element) {
    assert(invariant(element, element.isDeclaration));
    // Don't generate code for foreign elements.
    if (_backend.isForeign(element)) return null;
    if (element.isAbstract) return null;

    // Codegen inlines field initializers. It only needs to generate
    // code for checked setters.
    if (element.isField && element.isInstanceMember) {
      if (!_options.enableTypeAssertions ||
          element.enclosingElement.isClosure) {
        return null;
      }
    }
    return new CodegenWorkItem(_backend, element);
  }
}