package org.eclipse.jdt.internal.core.util;

/*Generated by MPS */

import jetbrains.mps.annotations.GeneratedClass;
import org.eclipse.jdt.internal.compiler.CompilationResult;
import org.eclipse.jdt.core.compiler.CategorizedProblem;
import org.eclipse.jdt.internal.compiler.ast.ASTNode;
import java.util.Map;
import org.eclipse.jdt.internal.compiler.impl.CompilerOptions;
import org.eclipse.jdt.internal.compiler.problem.ProblemReporter;
import org.eclipse.jdt.internal.compiler.DefaultErrorHandlingPolicies;
import org.eclipse.jdt.internal.compiler.problem.DefaultProblemFactory;
import java.util.Locale;
import org.eclipse.jdt.internal.compiler.env.ICompilationUnit;
import org.eclipse.jdt.internal.compiler.batch.CompilationUnit;
import org.eclipse.jdt.internal.compiler.ast.CompilationUnitDeclaration;
import org.eclipse.jdt.internal.compiler.ast.TypeDeclaration;
import org.eclipse.jdt.internal.compiler.ast.Expression;
import org.eclipse.jdt.internal.compiler.ast.ConstructorDeclaration;

/**
 * *******************************************************************************
 * * Copyright (c) 2002, 2009 IBM Corporation and others.
 * * All rights reserved. This program and the accompanying materials
 * * are made available under the terms of the Eclipse Public License v1.0
 * * which accompanies this distribution, and is available at
 * * http://www.eclipse.org/legal/epl-v10.html
 * *
 * * Contributors:
 * *     IBM Corporation - initial API and implementation
 * *******************************************************************************
 * 
 * Utility class to parse different code snippets
 */
@GeneratedClass(node = "r:40e27d97-dea1-422b-91e0-3b9f3271a7f1(org.eclipse.jdt.internal.core.util)/1218034168005183146", model = "r:40e27d97-dea1-422b-91e0-3b9f3271a7f1(org.eclipse.jdt.internal.core.util)")
public class CodeSnippetParsingUtil {
  public RecordedParsingInformation recordedParsingInformation;
  public boolean ignoreMethodBodies;
  public CodeSnippetParsingUtil(boolean ignoreMethodBodies) {
    this.ignoreMethodBodies = ignoreMethodBodies;
  }
  public CodeSnippetParsingUtil() {
    this(false);
  }
  private RecordedParsingInformation getRecordedParsingInformation(CompilationResult compilationResult, int[][] commentPositions) {
    int problemsCount = compilationResult.problemCount;
    CategorizedProblem[] problems = null;
    if (problemsCount != 0) {
      final CategorizedProblem[] compilationResultProblems = compilationResult.problems;
      if (compilationResultProblems.length == problemsCount) {
        problems = compilationResultProblems;
      } else {
        System.arraycopy(compilationResultProblems, 0, (problems = new CategorizedProblem[problemsCount]), 0, problemsCount);
      }
    }
    return new RecordedParsingInformation(problems, compilationResult.getLineSeparatorPositions(), commentPositions);
  }
  public ASTNode[] parseClassBodyDeclarations(char[] source, Map settings, boolean recordParsingInformation) {
    return parseClassBodyDeclarations(source, 0, source.length, settings, recordParsingInformation, false);
  }
  public ASTNode[] parseClassBodyDeclarations(char[] source, int offset, int length, Map settings, boolean recordParsingInformation, boolean enabledStatementRecovery) {
    if (source == null) {
      throw new IllegalArgumentException();
    }
    CompilerOptions compilerOptions = new CompilerOptions(settings);
    compilerOptions.ignoreMethodBodies = this.ignoreMethodBodies;
    final ProblemReporter problemReporter = new ProblemReporter(DefaultErrorHandlingPolicies.proceedWithAllProblems(), compilerOptions, new DefaultProblemFactory(Locale.getDefault()));
    CommentRecorderParser parser = new CommentRecorderParser(problemReporter, false);
    parser.setMethodsFullRecovery(false);
    parser.setStatementsRecovery(enabledStatementRecovery);
    ICompilationUnit sourceUnit = new CompilationUnit(source, "", compilerOptions.defaultEncoding);
    // $NON-NLS-1$
    CompilationResult compilationResult = new CompilationResult(sourceUnit, 0, 0, compilerOptions.maxProblemsPerUnit);
    final CompilationUnitDeclaration compilationUnitDeclaration = new CompilationUnitDeclaration(problemReporter, compilationResult, source.length);
    ASTNode[] result = parser.parseClassBodyDeclarations(source, offset, length, compilationUnitDeclaration);
    if (recordParsingInformation) {
      this.recordedParsingInformation = getRecordedParsingInformation(compilationResult, compilationUnitDeclaration.comments);
    }
    return result;
  }
  public CompilationUnitDeclaration parseCompilationUnit(char[] source, Map settings, boolean recordParsingInformation) {
    if (source == null) {
      throw new IllegalArgumentException();
    }
    CompilerOptions compilerOptions = new CompilerOptions(settings);
    compilerOptions.ignoreMethodBodies = this.ignoreMethodBodies;
    CommentRecorderParser parser = new CommentRecorderParser(new ProblemReporter(DefaultErrorHandlingPolicies.proceedWithAllProblems(), compilerOptions, new DefaultProblemFactory(Locale.getDefault())), false);
    ICompilationUnit sourceUnit = new CompilationUnit(source, "", compilerOptions.defaultEncoding);
    // $NON-NLS-1$
    final CompilationResult compilationResult = new CompilationResult(sourceUnit, 0, 0, compilerOptions.maxProblemsPerUnit);
    CompilationUnitDeclaration compilationUnitDeclaration = parser.dietParse(sourceUnit, compilationResult);
    if (recordParsingInformation) {
      this.recordedParsingInformation = getRecordedParsingInformation(compilationResult, compilationUnitDeclaration.comments);
    }
    if (compilationUnitDeclaration.ignoreMethodBodies) {
      compilationUnitDeclaration.ignoreFurtherInvestigation = true;
      // if initial diet parse did not work, no need to dig into method bodies.
      return compilationUnitDeclaration;
    }
    // fill the methods bodies in order for the code to be generated
    // real parse of the method....
    parser.scanner.setSource(compilationResult);
    TypeDeclaration[] types = compilationUnitDeclaration.types;
    if (types != null) {
      for (int i = 0; i < types.length; i++) {
        types[i].parseMethods(parser, compilationUnitDeclaration);
      }
    }
    if (recordParsingInformation) {
      this.recordedParsingInformation.updateRecordedParsingInformation(compilationResult);
    }
    return compilationUnitDeclaration;
  }
  public Expression parseExpression(char[] source, Map settings, boolean recordParsingInformation) {
    return parseExpression(source, 0, source.length, settings, recordParsingInformation);
  }
  public Expression parseExpression(char[] source, int offset, int length, Map settings, boolean recordParsingInformation) {
    if (source == null) {
      throw new IllegalArgumentException();
    }
    CompilerOptions compilerOptions = new CompilerOptions(settings);
    // in this case we don't want to ignore method bodies since we are parsing only an expression
    final ProblemReporter problemReporter = new ProblemReporter(DefaultErrorHandlingPolicies.proceedWithAllProblems(), compilerOptions, new DefaultProblemFactory(Locale.getDefault()));
    CommentRecorderParser parser = new CommentRecorderParser(problemReporter, false);
    ICompilationUnit sourceUnit = new CompilationUnit(source, "", compilerOptions.defaultEncoding);
    // $NON-NLS-1$
    CompilationResult compilationResult = new CompilationResult(sourceUnit, 0, 0, compilerOptions.maxProblemsPerUnit);
    CompilationUnitDeclaration unit = new CompilationUnitDeclaration(problemReporter, compilationResult, source.length);
    Expression result = parser.parseExpression(source, offset, length, unit, false);
    if (recordParsingInformation) {
      this.recordedParsingInformation = getRecordedParsingInformation(compilationResult, unit.comments);
    }
    return result;
  }
  public ConstructorDeclaration parseStatements(char[] source, Map settings, boolean recordParsingInformation, boolean enabledStatementRecovery) {
    return parseStatements(source, 0, source.length, settings, recordParsingInformation, enabledStatementRecovery);
  }
  public ConstructorDeclaration parseStatements(char[] source, int offset, int length, Map settings, boolean recordParsingInformation, boolean enabledStatementRecovery) {
    if (source == null) {
      throw new IllegalArgumentException();
    }
    CompilerOptions compilerOptions = new CompilerOptions(settings);
    // in this case we don't want to ignore method bodies since we are parsing only statements
    final ProblemReporter problemReporter = new ProblemReporter(DefaultErrorHandlingPolicies.proceedWithAllProblems(), compilerOptions, new DefaultProblemFactory(Locale.getDefault()));
    CommentRecorderParser parser = new CommentRecorderParser(problemReporter, false);
    parser.setMethodsFullRecovery(false);
    parser.setStatementsRecovery(enabledStatementRecovery);
    ICompilationUnit sourceUnit = new CompilationUnit(source, "", compilerOptions.defaultEncoding);
    // $NON-NLS-1$
    final CompilationResult compilationResult = new CompilationResult(sourceUnit, 0, 0, compilerOptions.maxProblemsPerUnit);
    CompilationUnitDeclaration compilationUnitDeclaration = new CompilationUnitDeclaration(problemReporter, compilationResult, length);
    ConstructorDeclaration constructorDeclaration = new ConstructorDeclaration(compilationResult);
    constructorDeclaration.sourceEnd = -1;
    constructorDeclaration.declarationSourceEnd = offset + length - 1;
    constructorDeclaration.bodyStart = offset;
    constructorDeclaration.bodyEnd = offset + length - 1;
    parser.scanner.setSource(compilationResult);
    parser.scanner.resetTo(offset, offset + length);
    parser.parse(constructorDeclaration, compilationUnitDeclaration, true);
    if (recordParsingInformation) {
      this.recordedParsingInformation = getRecordedParsingInformation(compilationResult, compilationUnitDeclaration.comments);
    }
    return constructorDeclaration;
  }
}
