java/java-psi-impl/src/com/intellij/psi/impl/source/tree/java/PsiCatchSectionImpl.java - platform/tools/idea - Git at Google

 /*
  * Copyright 2000-2012 JetBrains s.r.o.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  * http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 package com.intellij.psi.impl.source.tree.java;

 import com.intellij.codeInsight.ExceptionUtil;
 import com.intellij.lang.ASTNode;
 import com.intellij.openapi.diagnostic.Logger;
 import com.intellij.pom.java.LanguageLevel;
 import com.intellij.psi.*;
 import com.intellij.psi.impl.source.Constants;
 import com.intellij.psi.impl.source.tree.ChildRole;
 import com.intellij.psi.impl.source.tree.CompositePsiElement;
 import com.intellij.psi.scope.PsiScopeProcessor;
 import com.intellij.psi.scope.util.PsiScopesUtil;
 import com.intellij.psi.tree.ChildRoleBase;
 import com.intellij.psi.tree.IElementType;
 import com.intellij.psi.util.*;
 import com.intellij.util.NullableFunction;
 import com.intellij.util.containers.ContainerUtil;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;

 import java.util.Collection;
 import java.util.Collections;
 import java.util.List;

 /**
  * @author ven
  */
 public class PsiCatchSectionImpl extends CompositePsiElement implements PsiCatchSection, Constants {
   private static final Logger LOG = Logger.getInstance("#com.intellij.psi.impl.source.tree.java.PsiCatchSectionImpl");

   private final Object myTypesCacheLock = new Object();
   private CachedValue<List<PsiType>> myTypesCache = null;

   public PsiCatchSectionImpl() {
     super(CATCH_SECTION);
   }

   @Override
   public PsiParameter getParameter() {
     return (PsiParameter)findChildByRoleAsPsiElement(ChildRole.PARAMETER);
   }

   @Override
   public PsiCodeBlock getCatchBlock() {
     return (PsiCodeBlock)findChildByRoleAsPsiElement(ChildRole.CATCH_BLOCK);
   }

   @Override
   public PsiType getCatchType() {
     PsiParameter parameter = getParameter();
     if (parameter == null) return null;
     return parameter.getType();
   }

   @Override
   @NotNull
   public List<PsiType> getPreciseCatchTypes() {
     final PsiParameter parameter = getParameter();
     if (parameter == null) return Collections.emptyList();

     return getTypesCache().getValue();
   }

   @Override
   public void clearCaches() {
     super.clearCaches();
     synchronized (myTypesCacheLock) {
       myTypesCache = null;
     }
   }

   private CachedValue<List<PsiType>> getTypesCache() {
     synchronized (myTypesCacheLock) {
       if (myTypesCache == null) {
         final CachedValuesManager cacheManager = CachedValuesManager.getManager(getProject());
         myTypesCache = cacheManager.createCachedValue(new CachedValueProvider<List<PsiType>>() {
             @Override public Result<List<PsiType>> compute() {
               final List<PsiType> types = computePreciseCatchTypes(getParameter());
               return Result.create(types, PsiModificationTracker.MODIFICATION_COUNT);
             }
           }, false);
       }
       return myTypesCache;
     }
   }

   private List<PsiType> computePreciseCatchTypes(@Nullable final PsiParameter parameter) {
     if (parameter == null) {
       return ContainerUtil.emptyList();
     }

     PsiType declaredType = parameter.getType();

     // When the thrown expression is an ... exception parameter Ej (parameter) of a catch clause Cj (this) ...
     if (PsiUtil.getLanguageLevel(parameter).isAtLeast(LanguageLevel.JDK_1_7) &&
         isCatchParameterEffectivelyFinal(parameter, getCatchBlock())) {
       PsiTryStatement statement = getTryStatement();
       // ... and the try block of the try statement which declares Cj (tryBlock) can throw T ...
       Collection<PsiClassType> thrownTypes = getThrownTypes(statement);
       if (thrownTypes.isEmpty()) return Collections.emptyList();
       // ... and for all exception parameters Ei declared by any catch clauses Ci, 1 <= i < j,
       //     declared to the left of Cj for the same try statement, T is not assignable to Ei ...
       final PsiParameter[] parameters = statement.getCatchBlockParameters();
       List<PsiType> uncaughtTypes = ContainerUtil.mapNotNull(thrownTypes, new NullableFunction<PsiClassType, PsiType>() {
         @Override
         public PsiType fun(final PsiClassType thrownType) {
           for (int i = 0; i < parameters.length && parameters[i] != parameter; i++) {
             final PsiType catchType = parameters[i].getType();
             if (catchType.isAssignableFrom(thrownType)) return null;
           }
           return thrownType;
         }
       });
       // ... and T is assignable to Ej ...
       boolean passed = true;
       for (PsiType type : uncaughtTypes) {
         if (!declaredType.isAssignableFrom(type)) {
           passed = false;
           break;
         }
       }
       // ... the throw statement throws precisely the set of exception types T.
       if (passed) return uncaughtTypes;
     }

     return Collections.singletonList(declaredType);
   }

   private static Collection<PsiClassType> getThrownTypes(@NotNull PsiTryStatement statement) {
     Collection<PsiClassType> types = ContainerUtil.newArrayList();
     PsiCodeBlock tryBlock = statement.getTryBlock();
     if (tryBlock != null) {
       types.addAll(ExceptionUtil.getThrownExceptions(tryBlock));
     }
     PsiResourceList resourceList = statement.getResourceList();
     if (resourceList != null) {
       types.addAll(ExceptionUtil.getThrownExceptions(resourceList));
     }
     return types;
   }

   // do not use control flow here to avoid dead loop
   private static boolean isCatchParameterEffectivelyFinal(final PsiParameter parameter, @Nullable final PsiCodeBlock catchBlock) {
     final boolean[] result = {true};
     if (catchBlock != null) {
       catchBlock.accept(new JavaRecursiveElementWalkingVisitor() {
         @Override
         public void visitReferenceExpression(PsiReferenceExpression expression) {
           super.visitReferenceExpression(expression);
           if (expression.resolve() == parameter && PsiUtil.isAccessedForWriting(expression)) {
             result[0] = false;
             stopWalking();
           }
         }
       });
     }
     return result[0];
   }

   @Override
   @NotNull
   public PsiTryStatement getTryStatement() {
     return (PsiTryStatement)getParent();
   }

   @Override
   @Nullable
   public PsiJavaToken getLParenth() {
     return (PsiJavaToken)findChildByRole(ChildRole.CATCH_BLOCK_PARAMETER_LPARENTH);
   }

   @Override
   @Nullable
   public PsiJavaToken getRParenth() {
     return (PsiJavaToken)findChildByRole(ChildRole.CATCH_BLOCK_PARAMETER_RPARENTH);
   }

   @Override
   public void accept(@NotNull PsiElementVisitor visitor) {
     if (visitor instanceof JavaElementVisitor) {
       ((JavaElementVisitor)visitor).visitCatchSection(this);
     }
     else {
       visitor.visitElement(this);
     }
   }

   public String toString() {
     return "PsiCatchSection";
   }

   @Override
   public ASTNode findChildByRole(int role) {
     switch(role) {
       default:
         return null;

       case ChildRole.PARAMETER:
         return findChildByType(PARAMETER);

       case ChildRole.CATCH_KEYWORD:
         return findChildByType(CATCH_KEYWORD);

       case ChildRole.CATCH_BLOCK_PARAMETER_LPARENTH:
         return findChildByType(LPARENTH);

       case ChildRole.CATCH_BLOCK_PARAMETER_RPARENTH:
         return findChildByType(RPARENTH);

       case ChildRole.CATCH_BLOCK:
         return findChildByType(CODE_BLOCK);
     }
   }

   @Override
   public int getChildRole(ASTNode child) {
     LOG.assertTrue(child.getTreeParent() == this);
     IElementType i = child.getElementType();
     if (i == PARAMETER) {
       return ChildRole.PARAMETER;
     } else if (i == CODE_BLOCK) {
       return ChildRole.CATCH_BLOCK;
     } else if (i == CATCH_KEYWORD) {
       return ChildRole.CATCH_KEYWORD;
     } else if (i == LPARENTH) {
       return ChildRole.CATCH_BLOCK_PARAMETER_LPARENTH;
     } else if (i == RPARENTH) {
       return ChildRole.CATCH_BLOCK_PARAMETER_RPARENTH;
     }

     return ChildRoleBase.NONE;
   }

   @Override
   public boolean processDeclarations(@NotNull PsiScopeProcessor processor,
                                      @NotNull ResolveState state,
                                      PsiElement lastParent,
                                      @NotNull PsiElement place) {
     processor.handleEvent(PsiScopeProcessor.Event.SET_DECLARATION_HOLDER, this);
     if (lastParent == null || lastParent.getParent() != this)
       // Parent element should not see our vars
       return true;

     final PsiParameter catchParameter = getParameter();
     if (catchParameter != null) {
       return processor.execute(catchParameter, state);
     }

     return PsiScopesUtil.walkChildrenScopes(this, processor, state, lastParent, place);
   }
 }
	/*
	* Copyright 2000-2012 JetBrains s.r.o.
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/
	package com.intellij.psi.impl.source.tree.java;

	import com.intellij.codeInsight.ExceptionUtil;
	import com.intellij.lang.ASTNode;
	import com.intellij.openapi.diagnostic.Logger;
	import com.intellij.pom.java.LanguageLevel;
	import com.intellij.psi.*;
	import com.intellij.psi.impl.source.Constants;
	import com.intellij.psi.impl.source.tree.ChildRole;
	import com.intellij.psi.impl.source.tree.CompositePsiElement;
	import com.intellij.psi.scope.PsiScopeProcessor;
	import com.intellij.psi.scope.util.PsiScopesUtil;
	import com.intellij.psi.tree.ChildRoleBase;
	import com.intellij.psi.tree.IElementType;
	import com.intellij.psi.util.*;
	import com.intellij.util.NullableFunction;
	import com.intellij.util.containers.ContainerUtil;
	import org.jetbrains.annotations.NotNull;
	import org.jetbrains.annotations.Nullable;

	import java.util.Collection;
	import java.util.Collections;
	import java.util.List;

	/**
	* @author ven
	*/
	public class PsiCatchSectionImpl extends CompositePsiElement implements PsiCatchSection, Constants {
	private static final Logger LOG = Logger.getInstance("#com.intellij.psi.impl.source.tree.java.PsiCatchSectionImpl");

	private final Object myTypesCacheLock = new Object();
	private CachedValue<List<PsiType>> myTypesCache = null;

	public PsiCatchSectionImpl() {
	super(CATCH_SECTION);
	}

	@Override
	public PsiParameter getParameter() {
	return (PsiParameter)findChildByRoleAsPsiElement(ChildRole.PARAMETER);
	}

	@Override
	public PsiCodeBlock getCatchBlock() {
	return (PsiCodeBlock)findChildByRoleAsPsiElement(ChildRole.CATCH_BLOCK);
	}

	@Override
	public PsiType getCatchType() {
	PsiParameter parameter = getParameter();
	if (parameter == null) return null;
	return parameter.getType();
	}

	@Override
	@NotNull
	public List<PsiType> getPreciseCatchTypes() {
	final PsiParameter parameter = getParameter();
	if (parameter == null) return Collections.emptyList();

	return getTypesCache().getValue();
	}

	@Override
	public void clearCaches() {
	super.clearCaches();
	synchronized (myTypesCacheLock) {
	myTypesCache = null;
	}
	}

	private CachedValue<List<PsiType>> getTypesCache() {
	synchronized (myTypesCacheLock) {
	if (myTypesCache == null) {
	final CachedValuesManager cacheManager = CachedValuesManager.getManager(getProject());
	myTypesCache = cacheManager.createCachedValue(new CachedValueProvider<List<PsiType>>() {
	@Override public Result<List<PsiType>> compute() {
	final List<PsiType> types = computePreciseCatchTypes(getParameter());
	return Result.create(types, PsiModificationTracker.MODIFICATION_COUNT);
	}
	}, false);
	}
	return myTypesCache;
	}
	}

	private List<PsiType> computePreciseCatchTypes(@Nullable final PsiParameter parameter) {
	if (parameter == null) {
	return ContainerUtil.emptyList();
	}

	PsiType declaredType = parameter.getType();

	// When the thrown expression is an ... exception parameter Ej (parameter) of a catch clause Cj (this) ...
	if (PsiUtil.getLanguageLevel(parameter).isAtLeast(LanguageLevel.JDK_1_7) &&
	isCatchParameterEffectivelyFinal(parameter, getCatchBlock())) {
	PsiTryStatement statement = getTryStatement();
	// ... and the try block of the try statement which declares Cj (tryBlock) can throw T ...
	Collection<PsiClassType> thrownTypes = getThrownTypes(statement);
	if (thrownTypes.isEmpty()) return Collections.emptyList();
	// ... and for all exception parameters Ei declared by any catch clauses Ci, 1 <= i < j,
	// declared to the left of Cj for the same try statement, T is not assignable to Ei ...
	final PsiParameter[] parameters = statement.getCatchBlockParameters();
	List<PsiType> uncaughtTypes = ContainerUtil.mapNotNull(thrownTypes, new NullableFunction<PsiClassType, PsiType>() {
	@Override
	public PsiType fun(final PsiClassType thrownType) {
	for (int i = 0; i < parameters.length && parameters[i] != parameter; i++) {
	final PsiType catchType = parameters[i].getType();
	if (catchType.isAssignableFrom(thrownType)) return null;
	}
	return thrownType;
	}
	});
	// ... and T is assignable to Ej ...
	boolean passed = true;
	for (PsiType type : uncaughtTypes) {
	if (!declaredType.isAssignableFrom(type)) {
	passed = false;
	break;
	}
	}
	// ... the throw statement throws precisely the set of exception types T.
	if (passed) return uncaughtTypes;
	}

	return Collections.singletonList(declaredType);
	}

	private static Collection<PsiClassType> getThrownTypes(@NotNull PsiTryStatement statement) {
	Collection<PsiClassType> types = ContainerUtil.newArrayList();
	PsiCodeBlock tryBlock = statement.getTryBlock();
	if (tryBlock != null) {
	types.addAll(ExceptionUtil.getThrownExceptions(tryBlock));
	}
	PsiResourceList resourceList = statement.getResourceList();
	if (resourceList != null) {
	types.addAll(ExceptionUtil.getThrownExceptions(resourceList));
	}
	return types;
	}

	// do not use control flow here to avoid dead loop
	private static boolean isCatchParameterEffectivelyFinal(final PsiParameter parameter, @Nullable final PsiCodeBlock catchBlock) {
	final boolean[] result = {true};
	if (catchBlock != null) {
	catchBlock.accept(new JavaRecursiveElementWalkingVisitor() {
	@Override
	public void visitReferenceExpression(PsiReferenceExpression expression) {
	super.visitReferenceExpression(expression);
	if (expression.resolve() == parameter && PsiUtil.isAccessedForWriting(expression)) {
	result[0] = false;
	stopWalking();
	}
	}
	});
	}
	return result[0];
	}

	@Override
	@NotNull
	public PsiTryStatement getTryStatement() {
	return (PsiTryStatement)getParent();
	}

	@Override
	@Nullable
	public PsiJavaToken getLParenth() {
	return (PsiJavaToken)findChildByRole(ChildRole.CATCH_BLOCK_PARAMETER_LPARENTH);
	}

	@Override
	@Nullable
	public PsiJavaToken getRParenth() {
	return (PsiJavaToken)findChildByRole(ChildRole.CATCH_BLOCK_PARAMETER_RPARENTH);
	}

	@Override
	public void accept(@NotNull PsiElementVisitor visitor) {
	if (visitor instanceof JavaElementVisitor) {
	((JavaElementVisitor)visitor).visitCatchSection(this);
	}
	else {
	visitor.visitElement(this);
	}
	}

	public String toString() {
	return "PsiCatchSection";
	}

	@Override
	public ASTNode findChildByRole(int role) {
	switch(role) {
	default:
	return null;

	case ChildRole.PARAMETER:
	return findChildByType(PARAMETER);

	case ChildRole.CATCH_KEYWORD:
	return findChildByType(CATCH_KEYWORD);

	case ChildRole.CATCH_BLOCK_PARAMETER_LPARENTH:
	return findChildByType(LPARENTH);

	case ChildRole.CATCH_BLOCK_PARAMETER_RPARENTH:
	return findChildByType(RPARENTH);

	case ChildRole.CATCH_BLOCK:
	return findChildByType(CODE_BLOCK);
	}
	}

	@Override
	public int getChildRole(ASTNode child) {
	LOG.assertTrue(child.getTreeParent() == this);
	IElementType i = child.getElementType();
	if (i == PARAMETER) {
	return ChildRole.PARAMETER;
	} else if (i == CODE_BLOCK) {
	return ChildRole.CATCH_BLOCK;
	} else if (i == CATCH_KEYWORD) {
	return ChildRole.CATCH_KEYWORD;
	} else if (i == LPARENTH) {
	return ChildRole.CATCH_BLOCK_PARAMETER_LPARENTH;
	} else if (i == RPARENTH) {
	return ChildRole.CATCH_BLOCK_PARAMETER_RPARENTH;
	}

	return ChildRoleBase.NONE;
	}

	@Override
	public boolean processDeclarations(@NotNull PsiScopeProcessor processor,
	@NotNull ResolveState state,
	PsiElement lastParent,
	@NotNull PsiElement place) {
	processor.handleEvent(PsiScopeProcessor.Event.SET_DECLARATION_HOLDER, this);
	if (lastParent == null \|\| lastParent.getParent() != this)
	// Parent element should not see our vars
	return true;

	final PsiParameter catchParameter = getParameter();
	if (catchParameter != null) {
	return processor.execute(catchParameter, state);
	}

	return PsiScopesUtil.walkChildrenScopes(this, processor, state, lastParent, place);
	}
	}